/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using AvgWindow7Stride1Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Average, pooling::Forward>;
TYPED_TEST_SUITE(AvgWindow7Stride1Forward, GTestTypePairs);
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5, 15.,  15.5, 16.,  17.,  17.5, 18.,  18.5, 18.5, 19.,  19.5,
      20.,  21.,  21.5, 22.,  22.5, 22.5, 23.,  23.5, 24.,  25.,  25.5,
      26.,  26.5, 26.5, 27.,  27.5, 28.,  29.,  29.5, 30.,  30.5, 34.5,
      35.,  35.5, 36.,  37.,  37.5, 38.,  38.5, 38.5, 39.,  39.5, 40.,
      41.,  41.5, 42.,  42.5, 42.5, 43.,  43.5, 44.,  45.,  45.5, 46.,
      46.5, 46.5, 47.,  47.5, 48.,  49.,  49.5, 50.,  50.5};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28., 29., 36., 37.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28., 29., 29., 30., 30., 31., 31., 32., 33.,  34.,  34., 35., 35.,
      36., 36., 37., 36., 37., 37., 38., 38., 39.,  39.,  40., 41., 42.,
      42., 43., 43., 44., 44., 45., 44., 45., 45.,  46.,  46., 47., 47.,
      48., 49., 50., 50., 51., 51., 52., 52., 53.,  52.,  53., 53., 54.,
      54., 55., 55., 56., 57., 58., 58., 59., 59.,  60.,  60., 61., 68.,
      69., 69., 70., 70., 71., 71., 72., 73., 74.,  74.,  75., 75., 76.,
      76., 77., 76., 77., 77., 78., 78., 79., 79.,  80.,  81., 82., 82.,
      83., 83., 84., 84., 85., 84., 85., 85., 86.,  86.,  87., 87., 88.,
      89., 90., 90., 91., 91., 92., 92., 93., 92.,  93.,  93., 94., 94.,
      95., 95., 96., 97., 98., 98., 99., 99., 100., 100., 101.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55., 56., 57., 58.,
                                         71., 72., 73., 74.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  67.,  68.,  69.,  70.,
      69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,  85.,  86.,  87.,  88.,
      87.,  88.,  89.,  90.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      99.,  100., 101., 102., 101., 102., 103., 104., 103., 104., 105., 106.,
      103., 104., 105., 106., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 113., 114., 115., 116., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 135., 136., 137., 138.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 151., 152., 153., 154., 153., 154., 155., 156.,
      155., 156., 157., 158., 157., 158., 159., 160., 161., 162., 163., 164.,
      163., 164., 165., 166., 165., 166., 167., 168., 167., 168., 169., 170.,
      167., 168., 169., 170., 169., 170., 171., 172., 171., 172., 173., 174.,
      173., 174., 175., 176., 177., 178., 179., 180., 179., 180., 181., 182.,
      181., 182., 183., 184., 183., 184., 185., 186., 183., 184., 185., 186.,
      185., 186., 187., 188., 187., 188., 189., 190., 189., 190., 191., 192.,
      193., 194., 195., 196., 195., 196., 197., 198., 197., 198., 199., 200.,
      199., 200., 201., 202.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {109., 110., 111., 112., 113., 114.,
                                         115., 116., 141., 142., 143., 144.,
                                         145., 146., 147., 148.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16.,  16.5, 17.,  17.5, 18.5, 19.5, 20.,  20.5, 21.,  20.5, 21.,  21.5,
      22.,  23.,  24.,  24.5, 25.,  25.5, 25.,  25.5, 26.,  26.5, 27.5, 28.5,
      29.,  29.5, 30.,  29.5, 30.,  30.5, 31.,  32.,  33.,  33.5, 34.,  34.5,
      38.5, 39.,  39.5, 40.,  41.,  42.,  42.5, 43.,  43.5, 43.,  43.5, 44.,
      44.5, 45.5, 46.5, 47.,  47.5, 48.,  47.5, 48.,  48.5, 49.,  50.,  51.,
      51.5, 52.,  52.5, 52.,  52.5, 53.,  53.5, 54.5, 55.5, 56.,  56.5, 57.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31., 32., 33., 40., 41., 42.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  32.,  33.,  33.,  34.,  34.,  35.,  36.,  37.,  38.,  39.,
      39.,  40.,  40.,  41.,  41.,  42.,  40.,  41.,  41.,  42.,  42.,  43.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  49.,  49.,  50.,  50.,  51.,
      49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,  54.,  55.,  56.,  57.,
      57.,  58.,  58.,  59.,  59.,  60.,  58.,  59.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  68.,  69.,
      76.,  77.,  77.,  78.,  78.,  79.,  79.,  80.,  81.,  82.,  83.,  84.,
      84.,  85.,  85.,  86.,  86.,  87.,  85.,  86.,  86.,  87.,  87.,  88.,
      88.,  89.,  90.,  91.,  92.,  93.,  93.,  94.,  94.,  95.,  95.,  96.,
      94.,  95.,  95.,  96.,  96.,  97.,  97.,  98.,  99.,  100., 101., 102.,
      102., 103., 103., 104., 104., 105., 103., 104., 104., 105., 105., 106.,
      106., 107., 108., 109., 110., 111., 111., 112., 112., 113., 113., 114.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61., 62., 63., 64., 65., 66.,
                                         79., 80., 81., 82., 83., 84.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  97.,  98.,  97.,  98.,  99.,  100., 99.,  100., 101., 102.,
      97.,  98.,  99.,  100., 99.,  100., 101., 102., 101., 102., 103., 104.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 113., 114.,
      113., 114., 115., 116., 115., 116., 117., 118., 117., 118., 119., 120.,
      115., 116., 117., 118., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 135., 136., 137., 138.,
      151., 152., 153., 154., 153., 154., 155., 156., 155., 156., 157., 158.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      167., 168., 169., 170., 169., 170., 171., 172., 171., 172., 173., 174.,
      169., 170., 171., 172., 171., 172., 173., 174., 173., 174., 175., 176.,
      175., 176., 177., 178., 179., 180., 181., 182., 183., 184., 185., 186.,
      185., 186., 187., 188., 187., 188., 189., 190., 189., 190., 191., 192.,
      187., 188., 189., 190., 189., 190., 191., 192., 191., 192., 193., 194.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      203., 204., 205., 206., 205., 206., 207., 208., 207., 208., 209., 210.,
      205., 206., 207., 208., 207., 208., 209., 210., 209., 210., 211., 212.,
      211., 212., 213., 214., 215., 216., 217., 218., 219., 220., 221., 222.,
      221., 222., 223., 224., 223., 224., 225., 226., 225., 226., 227., 228.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5, 18.,  18.5, 19.,  20.,  21.,  22.,  22.5, 23.,  23.5, 22.5, 23.,
      23.5, 24.,  25.,  26.,  27.,  27.5, 28.,  28.5, 27.5, 28.,  28.5, 29.,
      30.,  31.,  32.,  32.5, 33.,  33.5, 32.5, 33.,  33.5, 34.,  35.,  36.,
      37.,  37.5, 38.,  38.5, 42.5, 43.,  43.5, 44.,  45.,  46.,  47.,  47.5,
      48.,  48.5, 47.5, 48.,  48.5, 49.,  50.,  51.,  52.,  52.5, 53.,  53.5,
      52.5, 53.,  53.5, 54.,  55.,  56.,  57.,  57.5, 58.,  58.5, 57.5, 58.,
      58.5, 59.,  60.,  61.,  62.,  62.5, 63.,  63.5};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {34., 35., 36., 37.,
                                         44., 45., 46., 47.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  35.,  36.,  36.,  37.,  37.,  38.,  39.,  40.,  41.,  42.,
      43.,  44.,  44.,  45.,  45.,  46.,  46.,  47.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  54.,  55.,
      55.,  56.,  56.,  57.,  54.,  55.,  55.,  56.,  56.,  57.,  57.,  58.,
      59.,  60.,  61.,  62.,  63.,  64.,  64.,  65.,  65.,  66.,  66.,  67.,
      64.,  65.,  65.,  66.,  66.,  67.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  94.,  95.,
      95.,  96.,  96.,  97.,  94.,  95.,  95.,  96.,  96.,  97.,  97.,  98.,
      99.,  100., 101., 102., 103., 104., 104., 105., 105., 106., 106., 107.,
      104., 105., 105., 106., 106., 107., 107., 108., 109., 110., 111., 112.,
      113., 114., 114., 115., 115., 116., 116., 117., 114., 115., 115., 116.,
      116., 117., 117., 118., 119., 120., 121., 122., 123., 124., 124., 125.,
      125., 126., 126., 127.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {67., 68., 69., 70., 71., 72.,
                                         73., 74., 87., 88., 89., 90.,
                                         91., 92., 93., 94.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 187., 188., 189., 190.,
      189., 190., 191., 192., 191., 192., 193., 194., 187., 188., 189., 190.,
      189., 190., 191., 192., 191., 192., 193., 194., 193., 194., 195., 196.,
      197., 198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,
      207., 208., 209., 210., 209., 210., 211., 212., 211., 212., 213., 214.,
      207., 208., 209., 210., 209., 210., 211., 212., 211., 212., 213., 214.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      225., 226., 227., 228., 227., 228., 229., 230., 229., 230., 231., 232.,
      231., 232., 233., 234., 227., 228., 229., 230., 229., 230., 231., 232.,
      231., 232., 233., 234., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 247., 248., 249., 250.,
      249., 250., 251., 252., 251., 252., 253., 254.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143.,
      144., 145., 146., 147., 148., 173., 174., 175., 176., 177., 178.,
      179., 180., 181., 182., 183., 184., 185., 186., 187., 188.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5, 15.,  15.5, 16.,  17.,  17.5, 18.,  18.5, 18.5, 19.,  19.5, 20.,
      21.,  21.5, 22.,  22.5, 22.5, 23.,  23.5, 24.,  25.,  25.5, 26.,  26.5,
      26.5, 27.,  27.5, 28.,  29.,  29.5, 30.,  30.5, 34.5, 35.,  35.5, 36.,
      37.,  37.5, 38.,  38.5, 42.5, 43.,  43.5, 44.,  45.,  45.5, 46.,  46.5,
      46.5, 47.,  47.5, 48.,  49.,  49.5, 50.,  50.5, 50.5, 51.,  51.5, 52.,
      53.,  53.5, 54.,  54.5, 54.5, 55.,  55.5, 56.,  57.,  57.5, 58.,  58.5};
  const std::array<int, 4> in_shape = {{1, 9, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28., 29., 36., 37., 44., 45.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  29.,  30.,  30.,  31.,  31.,  32.,  33.,  34.,  34.,  35.,
      35.,  36.,  36.,  37.,  36.,  37.,  37.,  38.,  38.,  39.,  39.,  40.,
      41.,  42.,  42.,  43.,  43.,  44.,  44.,  45.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,
      52.,  53.,  53.,  54.,  54.,  55.,  55.,  56.,  57.,  58.,  58.,  59.,
      59.,  60.,  60.,  61.,  68.,  69.,  69.,  70.,  70.,  71.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  90.,  91.,  91.,  92.,  92.,  93.,
      92.,  93.,  93.,  94.,  94.,  95.,  95.,  96.,  97.,  98.,  98.,  99.,
      99.,  100., 100., 101., 100., 101., 101., 102., 102., 103., 103., 104.,
      105., 106., 106., 107., 107., 108., 108., 109., 108., 109., 109., 110.,
      110., 111., 111., 112., 113., 114., 114., 115., 115., 116., 116., 117.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55., 56., 57., 58., 71., 72.,
                                         73., 74., 87., 88., 89., 90.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  67.,  68.,  69.,  70.,
      69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,  85.,  86.,  87.,  88.,
      87.,  88.,  89.,  90.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      99.,  100., 101., 102., 101., 102., 103., 104., 103., 104., 105., 106.,
      103., 104., 105., 106., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 113., 114., 115., 116., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 135., 136., 137., 138.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 181., 182., 181., 182., 183., 184., 183., 184., 185., 186.,
      183., 184., 185., 186., 185., 186., 187., 188., 187., 188., 189., 190.,
      189., 190., 191., 192., 193., 194., 195., 196., 195., 196., 197., 198.,
      197., 198., 199., 200., 199., 200., 201., 202., 199., 200., 201., 202.,
      201., 202., 203., 204., 203., 204., 205., 206., 205., 206., 207., 208.,
      209., 210., 211., 212., 211., 212., 213., 214., 213., 214., 215., 216.,
      215., 216., 217., 218., 215., 216., 217., 218., 217., 218., 219., 220.,
      219., 220., 221., 222., 221., 222., 223., 224., 225., 226., 227., 228.,
      227., 228., 229., 230., 229., 230., 231., 232., 231., 232., 233., 234.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 141., 142., 143., 144.,
      145., 146., 147., 148., 173., 174., 175., 176., 177., 178., 179., 180.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16.,  16.5, 17.,  17.5, 18.5, 19.5, 20.,  20.5, 21.,  20.5, 21.,  21.5,
      22.,  23.,  24.,  24.5, 25.,  25.5, 25.,  25.5, 26.,  26.5, 27.5, 28.5,
      29.,  29.5, 30.,  29.5, 30.,  30.5, 31.,  32.,  33.,  33.5, 34.,  34.5,
      38.5, 39.,  39.5, 40.,  41.,  42.,  42.5, 43.,  43.5, 47.5, 48.,  48.5,
      49.,  50.,  51.,  51.5, 52.,  52.5, 52.,  52.5, 53.,  53.5, 54.5, 55.5,
      56.,  56.5, 57.,  56.5, 57.,  57.5, 58.,  59.,  60.,  60.5, 61.,  61.5,
      61.,  61.5, 62.,  62.5, 63.5, 64.5, 65.,  65.5, 66.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31., 32., 33., 40., 41.,
                                         42., 49., 50., 51.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  32.,  33.,  33.,  34.,  34.,  35.,  36.,  37.,  38.,  39.,
      39.,  40.,  40.,  41.,  41.,  42.,  40.,  41.,  41.,  42.,  42.,  43.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  49.,  49.,  50.,  50.,  51.,
      49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,  54.,  55.,  56.,  57.,
      57.,  58.,  58.,  59.,  59.,  60.,  58.,  59.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  68.,  69.,
      76.,  77.,  77.,  78.,  78.,  79.,  79.,  80.,  81.,  82.,  83.,  84.,
      84.,  85.,  85.,  86.,  86.,  87.,  94.,  95.,  95.,  96.,  96.,  97.,
      97.,  98.,  99.,  100., 101., 102., 102., 103., 103., 104., 104., 105.,
      103., 104., 104., 105., 105., 106., 106., 107., 108., 109., 110., 111.,
      111., 112., 112., 113., 113., 114., 112., 113., 113., 114., 114., 115.,
      115., 116., 117., 118., 119., 120., 120., 121., 121., 122., 122., 123.,
      121., 122., 122., 123., 123., 124., 124., 125., 126., 127., 128., 129.,
      129., 130., 130., 131., 131., 132.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61., 62., 63., 64.,  65.,  66.,
                                         79., 80., 81., 82.,  83.,  84.,
                                         97., 98., 99., 100., 101., 102.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  97.,  98.,  97.,  98.,  99.,  100., 99.,  100., 101., 102.,
      97.,  98.,  99.,  100., 99.,  100., 101., 102., 101., 102., 103., 104.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 113., 114.,
      113., 114., 115., 116., 115., 116., 117., 118., 117., 118., 119., 120.,
      115., 116., 117., 118., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 135., 136., 137., 138.,
      151., 152., 153., 154., 153., 154., 155., 156., 155., 156., 157., 158.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      167., 168., 169., 170., 169., 170., 171., 172., 171., 172., 173., 174.,
      187., 188., 189., 190., 189., 190., 191., 192., 191., 192., 193., 194.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      203., 204., 205., 206., 205., 206., 207., 208., 207., 208., 209., 210.,
      205., 206., 207., 208., 207., 208., 209., 210., 209., 210., 211., 212.,
      211., 212., 213., 214., 215., 216., 217., 218., 219., 220., 221., 222.,
      221., 222., 223., 224., 223., 224., 225., 226., 225., 226., 227., 228.,
      223., 224., 225., 226., 225., 226., 227., 228., 227., 228., 229., 230.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      239., 240., 241., 242., 241., 242., 243., 244., 243., 244., 245., 246.,
      241., 242., 243., 244., 243., 244., 245., 246., 245., 246., 247., 248.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 257., 258.,
      257., 258., 259., 260., 259., 260., 261., 262., 261., 262., 263., 264.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5, 18.,  18.5, 19.,  20.,  21.,  22.,  22.5, 23.,  23.5, 22.5, 23.,
      23.5, 24.,  25.,  26.,  27.,  27.5, 28.,  28.5, 27.5, 28.,  28.5, 29.,
      30.,  31.,  32.,  32.5, 33.,  33.5, 32.5, 33.,  33.5, 34.,  35.,  36.,
      37.,  37.5, 38.,  38.5, 42.5, 43.,  43.5, 44.,  45.,  46.,  47.,  47.5,
      48.,  48.5, 52.5, 53.,  53.5, 54.,  55.,  56.,  57.,  57.5, 58.,  58.5,
      57.5, 58.,  58.5, 59.,  60.,  61.,  62.,  62.5, 63.,  63.5, 62.5, 63.,
      63.5, 64.,  65.,  66.,  67.,  67.5, 68.,  68.5, 67.5, 68.,  68.5, 69.,
      70.,  71.,  72.,  72.5, 73.,  73.5};
  const std::array<int, 4> in_shape = {{1, 9, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {34., 35., 36., 37., 44., 45.,
                                         46., 47., 54., 55., 56., 57.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  35.,  36.,  36.,  37.,  37.,  38.,  39.,  40.,  41.,  42.,
      43.,  44.,  44.,  45.,  45.,  46.,  46.,  47.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  54.,  55.,
      55.,  56.,  56.,  57.,  54.,  55.,  55.,  56.,  56.,  57.,  57.,  58.,
      59.,  60.,  61.,  62.,  63.,  64.,  64.,  65.,  65.,  66.,  66.,  67.,
      64.,  65.,  65.,  66.,  66.,  67.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  94.,  95.,
      95.,  96.,  96.,  97.,  104., 105., 105., 106., 106., 107., 107., 108.,
      109., 110., 111., 112., 113., 114., 114., 115., 115., 116., 116., 117.,
      114., 115., 115., 116., 116., 117., 117., 118., 119., 120., 121., 122.,
      123., 124., 124., 125., 125., 126., 126., 127., 124., 125., 125., 126.,
      126., 127., 127., 128., 129., 130., 131., 132., 133., 134., 134., 135.,
      135., 136., 136., 137., 134., 135., 135., 136., 136., 137., 137., 138.,
      139., 140., 141., 142., 143., 144., 144., 145., 145., 146., 146., 147.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67., 68., 69., 70., 71.,  72.,  73.,  74.,  87.,  88.,  89.,  90.,
      91., 92., 93., 94., 107., 108., 109., 110., 111., 112., 113., 114.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 187., 188., 189., 190.,
      189., 190., 191., 192., 191., 192., 193., 194., 207., 208., 209., 210.,
      209., 210., 211., 212., 211., 212., 213., 214., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.,
      227., 228., 229., 230., 229., 230., 231., 232., 231., 232., 233., 234.,
      227., 228., 229., 230., 229., 230., 231., 232., 231., 232., 233., 234.,
      233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243., 244.,
      245., 246., 247., 248., 247., 248., 249., 250., 249., 250., 251., 252.,
      251., 252., 253., 254., 247., 248., 249., 250., 249., 250., 251., 252.,
      251., 252., 253., 254., 253., 254., 255., 256., 257., 258., 259., 260.,
      261., 262., 263., 264., 265., 266., 267., 268., 267., 268., 269., 270.,
      269., 270., 271., 272., 271., 272., 273., 274., 267., 268., 269., 270.,
      269., 270., 271., 272., 271., 272., 273., 274., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      287., 288., 289., 290., 289., 290., 291., 292., 291., 292., 293., 294.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5, 15.,  15.5, 16.,  17.,  17.5, 18.,  18.5, 18.5, 19.,  19.5, 20.,
      21.,  21.5, 22.,  22.5, 22.5, 23.,  23.5, 24.,  25.,  25.5, 26.,  26.5,
      26.5, 27.,  27.5, 28.,  29.,  29.5, 30.,  30.5, 34.5, 35.,  35.5, 36.,
      37.,  37.5, 38.,  38.5, 42.5, 43.,  43.5, 44.,  45.,  45.5, 46.,  46.5,
      50.5, 51.,  51.5, 52.,  53.,  53.5, 54.,  54.5, 54.5, 55.,  55.5, 56.,
      57.,  57.5, 58.,  58.5, 58.5, 59.,  59.5, 60.,  61.,  61.5, 62.,  62.5,
      62.5, 63.,  63.5, 64.,  65.,  65.5, 66.,  66.5};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28., 29., 36., 37.,
                                         44., 45., 52., 53.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  29.,  30.,  30.,  31.,  31.,  32.,  33.,  34.,  34.,  35.,
      35.,  36.,  36.,  37.,  36.,  37.,  37.,  38.,  38.,  39.,  39.,  40.,
      41.,  42.,  42.,  43.,  43.,  44.,  44.,  45.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,
      52.,  53.,  53.,  54.,  54.,  55.,  55.,  56.,  57.,  58.,  58.,  59.,
      59.,  60.,  60.,  61.,  68.,  69.,  69.,  70.,  70.,  71.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  90.,  91.,  91.,  92.,  92.,  93.,
      100., 101., 101., 102., 102., 103., 103., 104., 105., 106., 106., 107.,
      107., 108., 108., 109., 108., 109., 109., 110., 110., 111., 111., 112.,
      113., 114., 114., 115., 115., 116., 116., 117., 116., 117., 117., 118.,
      118., 119., 119., 120., 121., 122., 122., 123., 123., 124., 124., 125.,
      124., 125., 125., 126., 126., 127., 127., 128., 129., 130., 130., 131.,
      131., 132., 132., 133.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55.,  56.,  57.,  58., 71., 72.,
                                         73.,  74.,  87.,  88., 89., 90.,
                                         103., 104., 105., 106.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  67.,  68.,  69.,  70.,
      69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,  85.,  86.,  87.,  88.,
      87.,  88.,  89.,  90.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      99.,  100., 101., 102., 101., 102., 103., 104., 103., 104., 105., 106.,
      103., 104., 105., 106., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 113., 114., 115., 116., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 135., 136., 137., 138.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 181., 182., 181., 182., 183., 184., 183., 184., 185., 186.,
      199., 200., 201., 202., 201., 202., 203., 204., 203., 204., 205., 206.,
      205., 206., 207., 208., 209., 210., 211., 212., 211., 212., 213., 214.,
      213., 214., 215., 216., 215., 216., 217., 218., 215., 216., 217., 218.,
      217., 218., 219., 220., 219., 220., 221., 222., 221., 222., 223., 224.,
      225., 226., 227., 228., 227., 228., 229., 230., 229., 230., 231., 232.,
      231., 232., 233., 234., 231., 232., 233., 234., 233., 234., 235., 236.,
      235., 236., 237., 238., 237., 238., 239., 240., 241., 242., 243., 244.,
      243., 244., 245., 246., 245., 246., 247., 248., 247., 248., 249., 250.,
      247., 248., 249., 250., 249., 250., 251., 252., 251., 252., 253., 254.,
      253., 254., 255., 256., 257., 258., 259., 260., 259., 260., 261., 262.,
      261., 262., 263., 264., 263., 264., 265., 266.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 141., 142., 143.,
      144., 145., 146., 147., 148., 173., 174., 175., 176., 177., 178.,
      179., 180., 205., 206., 207., 208., 209., 210., 211., 212.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16.,  16.5, 17.,  17.5, 18.5, 19.5, 20.,  20.5, 21.,  20.5, 21.,  21.5,
      22.,  23.,  24.,  24.5, 25.,  25.5, 25.,  25.5, 26.,  26.5, 27.5, 28.5,
      29.,  29.5, 30.,  29.5, 30.,  30.5, 31.,  32.,  33.,  33.5, 34.,  34.5,
      38.5, 39.,  39.5, 40.,  41.,  42.,  42.5, 43.,  43.5, 47.5, 48.,  48.5,
      49.,  50.,  51.,  51.5, 52.,  52.5, 56.5, 57.,  57.5, 58.,  59.,  60.,
      60.5, 61.,  61.5, 61.,  61.5, 62.,  62.5, 63.5, 64.5, 65.,  65.5, 66.,
      65.5, 66.,  66.5, 67.,  68.,  69.,  69.5, 70.,  70.5, 70.,  70.5, 71.,
      71.5, 72.5, 73.5, 74.,  74.5, 75.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31., 32., 33., 40., 41., 42.,
                                         49., 50., 51., 58., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  32.,  33.,  33.,  34.,  34.,  35.,  36.,  37.,  38.,  39.,
      39.,  40.,  40.,  41.,  41.,  42.,  40.,  41.,  41.,  42.,  42.,  43.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  49.,  49.,  50.,  50.,  51.,
      49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,  54.,  55.,  56.,  57.,
      57.,  58.,  58.,  59.,  59.,  60.,  58.,  59.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  68.,  69.,
      76.,  77.,  77.,  78.,  78.,  79.,  79.,  80.,  81.,  82.,  83.,  84.,
      84.,  85.,  85.,  86.,  86.,  87.,  94.,  95.,  95.,  96.,  96.,  97.,
      97.,  98.,  99.,  100., 101., 102., 102., 103., 103., 104., 104., 105.,
      112., 113., 113., 114., 114., 115., 115., 116., 117., 118., 119., 120.,
      120., 121., 121., 122., 122., 123., 121., 122., 122., 123., 123., 124.,
      124., 125., 126., 127., 128., 129., 129., 130., 130., 131., 131., 132.,
      130., 131., 131., 132., 132., 133., 133., 134., 135., 136., 137., 138.,
      138., 139., 139., 140., 140., 141., 139., 140., 140., 141., 141., 142.,
      142., 143., 144., 145., 146., 147., 147., 148., 148., 149., 149., 150.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61., 62., 63., 64.,  65.,  66.,  79.,  80.,  81.,  82.,  83.,  84.,
      97., 98., 99., 100., 101., 102., 115., 116., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  97.,  98.,  97.,  98.,  99.,  100., 99.,  100., 101., 102.,
      97.,  98.,  99.,  100., 99.,  100., 101., 102., 101., 102., 103., 104.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 113., 114.,
      113., 114., 115., 116., 115., 116., 117., 118., 117., 118., 119., 120.,
      115., 116., 117., 118., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 135., 136., 137., 138.,
      151., 152., 153., 154., 153., 154., 155., 156., 155., 156., 157., 158.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      167., 168., 169., 170., 169., 170., 171., 172., 171., 172., 173., 174.,
      187., 188., 189., 190., 189., 190., 191., 192., 191., 192., 193., 194.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      203., 204., 205., 206., 205., 206., 207., 208., 207., 208., 209., 210.,
      223., 224., 225., 226., 225., 226., 227., 228., 227., 228., 229., 230.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      239., 240., 241., 242., 241., 242., 243., 244., 243., 244., 245., 246.,
      241., 242., 243., 244., 243., 244., 245., 246., 245., 246., 247., 248.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 257., 258.,
      257., 258., 259., 260., 259., 260., 261., 262., 261., 262., 263., 264.,
      259., 260., 261., 262., 261., 262., 263., 264., 263., 264., 265., 266.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      275., 276., 277., 278., 277., 278., 279., 280., 279., 280., 281., 282.,
      277., 278., 279., 280., 279., 280., 281., 282., 281., 282., 283., 284.,
      283., 284., 285., 286., 287., 288., 289., 290., 291., 292., 293., 294.,
      293., 294., 295., 296., 295., 296., 297., 298., 297., 298., 299., 300.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5, 18.,  18.5, 19.,  20.,  21.,  22.,  22.5, 23.,  23.5, 22.5, 23.,
      23.5, 24.,  25.,  26.,  27.,  27.5, 28.,  28.5, 27.5, 28.,  28.5, 29.,
      30.,  31.,  32.,  32.5, 33.,  33.5, 32.5, 33.,  33.5, 34.,  35.,  36.,
      37.,  37.5, 38.,  38.5, 42.5, 43.,  43.5, 44.,  45.,  46.,  47.,  47.5,
      48.,  48.5, 52.5, 53.,  53.5, 54.,  55.,  56.,  57.,  57.5, 58.,  58.5,
      62.5, 63.,  63.5, 64.,  65.,  66.,  67.,  67.5, 68.,  68.5, 67.5, 68.,
      68.5, 69.,  70.,  71.,  72.,  72.5, 73.,  73.5, 72.5, 73.,  73.5, 74.,
      75.,  76.,  77.,  77.5, 78.,  78.5, 77.5, 78.,  78.5, 79.,  80.,  81.,
      82.,  82.5, 83.,  83.5};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {34., 35., 36., 37., 44., 45.,
                                         46., 47., 54., 55., 56., 57.,
                                         64., 65., 66., 67.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  35.,  36.,  36.,  37.,  37.,  38.,  39.,  40.,  41.,  42.,
      43.,  44.,  44.,  45.,  45.,  46.,  46.,  47.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  54.,  55.,
      55.,  56.,  56.,  57.,  54.,  55.,  55.,  56.,  56.,  57.,  57.,  58.,
      59.,  60.,  61.,  62.,  63.,  64.,  64.,  65.,  65.,  66.,  66.,  67.,
      64.,  65.,  65.,  66.,  66.,  67.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  94.,  95.,
      95.,  96.,  96.,  97.,  104., 105., 105., 106., 106., 107., 107., 108.,
      109., 110., 111., 112., 113., 114., 114., 115., 115., 116., 116., 117.,
      124., 125., 125., 126., 126., 127., 127., 128., 129., 130., 131., 132.,
      133., 134., 134., 135., 135., 136., 136., 137., 134., 135., 135., 136.,
      136., 137., 137., 138., 139., 140., 141., 142., 143., 144., 144., 145.,
      145., 146., 146., 147., 144., 145., 145., 146., 146., 147., 147., 148.,
      149., 150., 151., 152., 153., 154., 154., 155., 155., 156., 156., 157.,
      154., 155., 155., 156., 156., 157., 157., 158., 159., 160., 161., 162.,
      163., 164., 164., 165., 165., 166., 166., 167.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  87.,  88.,  89.,
      90.,  91.,  92.,  93.,  94.,  107., 108., 109., 110., 111., 112.,
      113., 114., 127., 128., 129., 130., 131., 132., 133., 134.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 187., 188., 189., 190.,
      189., 190., 191., 192., 191., 192., 193., 194., 207., 208., 209., 210.,
      209., 210., 211., 212., 211., 212., 213., 214., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.,
      227., 228., 229., 230., 229., 230., 231., 232., 231., 232., 233., 234.,
      247., 248., 249., 250., 249., 250., 251., 252., 251., 252., 253., 254.,
      253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 267., 268., 269., 270., 269., 270., 271., 272.,
      271., 272., 273., 274., 267., 268., 269., 270., 269., 270., 271., 272.,
      271., 272., 273., 274., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 287., 288., 289., 290.,
      289., 290., 291., 292., 291., 292., 293., 294., 287., 288., 289., 290.,
      289., 290., 291., 292., 291., 292., 293., 294., 293., 294., 295., 296.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      307., 308., 309., 310., 309., 310., 311., 312., 311., 312., 313., 314.,
      307., 308., 309., 310., 309., 310., 311., 312., 311., 312., 313., 314.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      325., 326., 327., 328., 327., 328., 329., 330., 329., 330., 331., 332.,
      331., 332., 333., 334.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143.,
      144., 145., 146., 147., 148., 173., 174., 175., 176., 177., 178.,
      179., 180., 181., 182., 183., 184., 185., 186., 187., 188., 213.,
      214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      225., 226., 227., 228., 253., 254., 255., 256., 257., 258., 259.,
      260., 261., 262., 263., 264., 265., 266., 267., 268.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5,  15.,   15.5,  16.,   17.,   17.5,  18.,   18.5,  18.5,  19.,
      19.5,  20.,   21.,   21.5,  22.,   22.5,  22.5,  23.,   23.5,  24.,
      25.,   25.5,  26.,   26.5,  26.5,  27.,   27.5,  28.,   29.,   29.5,
      30.,   30.5,  34.5,  35.,   35.5,  36.,   37.,   37.5,  38.,   38.5,
      38.5,  39.,   39.5,  40.,   41.,   41.5,  42.,   42.5,  42.5,  43.,
      43.5,  44.,   45.,   45.5,  46.,   46.5,  46.5,  47.,   47.5,  48.,
      49.,   49.5,  50.,   50.5,  78.5,  79.,   79.5,  80.,   81.,   81.5,
      82.,   82.5,  82.5,  83.,   83.5,  84.,   85.,   85.5,  86.,   86.5,
      86.5,  87.,   87.5,  88.,   89.,   89.5,  90.,   90.5,  90.5,  91.,
      91.5,  92.,   93.,   93.5,  94.,   94.5,  98.5,  99.,   99.5,  100.,
      101.,  101.5, 102.,  102.5, 102.5, 103.,  103.5, 104.,  105.,  105.5,
      106.,  106.5, 106.5, 107.,  107.5, 108.,  109.,  109.5, 110.,  110.5,
      110.5, 111.,  111.5, 112.,  113.,  113.5, 114.,  114.5, 142.5, 143.,
      143.5, 144.,  145.,  145.5, 146.,  146.5, 146.5, 147.,  147.5, 148.,
      149.,  149.5, 150.,  150.5, 150.5, 151.,  151.5, 152.,  153.,  153.5,
      154.,  154.5, 154.5, 155.,  155.5, 156.,  157.,  157.5, 158.,  158.5,
      162.5, 163.,  163.5, 164.,  165.,  165.5, 166.,  166.5, 166.5, 167.,
      167.5, 168.,  169.,  169.5, 170.,  170.5, 170.5, 171.,  171.5, 172.,
      173.,  173.5, 174.,  174.5, 174.5, 175.,  175.5, 176.,  177.,  177.5,
      178.,  178.5};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28.,  29.,  36.,  37.,  92.,  93.,
                                         100., 101., 156., 157., 164., 165.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  29.,  30.,  30.,  31.,  31.,  32.,  33.,  34.,  34.,  35.,
      35.,  36.,  36.,  37.,  36.,  37.,  37.,  38.,  38.,  39.,  39.,  40.,
      41.,  42.,  42.,  43.,  43.,  44.,  44.,  45.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,
      52.,  53.,  53.,  54.,  54.,  55.,  55.,  56.,  57.,  58.,  58.,  59.,
      59.,  60.,  60.,  61.,  68.,  69.,  69.,  70.,  70.,  71.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  76.,  77.,  77.,  78.,
      78.,  79.,  79.,  80.,  81.,  82.,  82.,  83.,  83.,  84.,  84.,  85.,
      84.,  85.,  85.,  86.,  86.,  87.,  87.,  88.,  89.,  90.,  90.,  91.,
      91.,  92.,  92.,  93.,  92.,  93.,  93.,  94.,  94.,  95.,  95.,  96.,
      97.,  98.,  98.,  99.,  99.,  100., 100., 101., 156., 157., 157., 158.,
      158., 159., 159., 160., 161., 162., 162., 163., 163., 164., 164., 165.,
      164., 165., 165., 166., 166., 167., 167., 168., 169., 170., 170., 171.,
      171., 172., 172., 173., 172., 173., 173., 174., 174., 175., 175., 176.,
      177., 178., 178., 179., 179., 180., 180., 181., 180., 181., 181., 182.,
      182., 183., 183., 184., 185., 186., 186., 187., 187., 188., 188., 189.,
      196., 197., 197., 198., 198., 199., 199., 200., 201., 202., 202., 203.,
      203., 204., 204., 205., 204., 205., 205., 206., 206., 207., 207., 208.,
      209., 210., 210., 211., 211., 212., 212., 213., 212., 213., 213., 214.,
      214., 215., 215., 216., 217., 218., 218., 219., 219., 220., 220., 221.,
      220., 221., 221., 222., 222., 223., 223., 224., 225., 226., 226., 227.,
      227., 228., 228., 229., 284., 285., 285., 286., 286., 287., 287., 288.,
      289., 290., 290., 291., 291., 292., 292., 293., 292., 293., 293., 294.,
      294., 295., 295., 296., 297., 298., 298., 299., 299., 300., 300., 301.,
      300., 301., 301., 302., 302., 303., 303., 304., 305., 306., 306., 307.,
      307., 308., 308., 309., 308., 309., 309., 310., 310., 311., 311., 312.,
      313., 314., 314., 315., 315., 316., 316., 317., 324., 325., 325., 326.,
      326., 327., 327., 328., 329., 330., 330., 331., 331., 332., 332., 333.,
      332., 333., 333., 334., 334., 335., 335., 336., 337., 338., 338., 339.,
      339., 340., 340., 341., 340., 341., 341., 342., 342., 343., 343., 344.,
      345., 346., 346., 347., 347., 348., 348., 349., 348., 349., 349., 350.,
      350., 351., 351., 352., 353., 354., 354., 355., 355., 356., 356., 357.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  71.,  72.,  73.,  74.,  183., 184., 185., 186.,
      199., 200., 201., 202., 311., 312., 313., 314., 327., 328., 329., 330.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  67.,  68.,  69.,  70.,
      69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,  85.,  86.,  87.,  88.,
      87.,  88.,  89.,  90.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      99.,  100., 101., 102., 101., 102., 103., 104., 103., 104., 105., 106.,
      103., 104., 105., 106., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 113., 114., 115., 116., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 135., 136., 137., 138.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 151., 152., 153., 154., 153., 154., 155., 156.,
      155., 156., 157., 158., 157., 158., 159., 160., 161., 162., 163., 164.,
      163., 164., 165., 166., 165., 166., 167., 168., 167., 168., 169., 170.,
      167., 168., 169., 170., 169., 170., 171., 172., 171., 172., 173., 174.,
      173., 174., 175., 176., 177., 178., 179., 180., 179., 180., 181., 182.,
      181., 182., 183., 184., 183., 184., 185., 186., 183., 184., 185., 186.,
      185., 186., 187., 188., 187., 188., 189., 190., 189., 190., 191., 192.,
      193., 194., 195., 196., 195., 196., 197., 198., 197., 198., 199., 200.,
      199., 200., 201., 202., 311., 312., 313., 314., 313., 314., 315., 316.,
      315., 316., 317., 318., 317., 318., 319., 320., 321., 322., 323., 324.,
      323., 324., 325., 326., 325., 326., 327., 328., 327., 328., 329., 330.,
      327., 328., 329., 330., 329., 330., 331., 332., 331., 332., 333., 334.,
      333., 334., 335., 336., 337., 338., 339., 340., 339., 340., 341., 342.,
      341., 342., 343., 344., 343., 344., 345., 346., 343., 344., 345., 346.,
      345., 346., 347., 348., 347., 348., 349., 350., 349., 350., 351., 352.,
      353., 354., 355., 356., 355., 356., 357., 358., 357., 358., 359., 360.,
      359., 360., 361., 362., 359., 360., 361., 362., 361., 362., 363., 364.,
      363., 364., 365., 366., 365., 366., 367., 368., 369., 370., 371., 372.,
      371., 372., 373., 374., 373., 374., 375., 376., 375., 376., 377., 378.,
      391., 392., 393., 394., 393., 394., 395., 396., 395., 396., 397., 398.,
      397., 398., 399., 400., 401., 402., 403., 404., 403., 404., 405., 406.,
      405., 406., 407., 408., 407., 408., 409., 410., 407., 408., 409., 410.,
      409., 410., 411., 412., 411., 412., 413., 414., 413., 414., 415., 416.,
      417., 418., 419., 420., 419., 420., 421., 422., 421., 422., 423., 424.,
      423., 424., 425., 426., 423., 424., 425., 426., 425., 426., 427., 428.,
      427., 428., 429., 430., 429., 430., 431., 432., 433., 434., 435., 436.,
      435., 436., 437., 438., 437., 438., 439., 440., 439., 440., 441., 442.,
      439., 440., 441., 442., 441., 442., 443., 444., 443., 444., 445., 446.,
      445., 446., 447., 448., 449., 450., 451., 452., 451., 452., 453., 454.,
      453., 454., 455., 456., 455., 456., 457., 458., 567., 568., 569., 570.,
      569., 570., 571., 572., 571., 572., 573., 574., 573., 574., 575., 576.,
      577., 578., 579., 580., 579., 580., 581., 582., 581., 582., 583., 584.,
      583., 584., 585., 586., 583., 584., 585., 586., 585., 586., 587., 588.,
      587., 588., 589., 590., 589., 590., 591., 592., 593., 594., 595., 596.,
      595., 596., 597., 598., 597., 598., 599., 600., 599., 600., 601., 602.,
      599., 600., 601., 602., 601., 602., 603., 604., 603., 604., 605., 606.,
      605., 606., 607., 608., 609., 610., 611., 612., 611., 612., 613., 614.,
      613., 614., 615., 616., 615., 616., 617., 618., 615., 616., 617., 618.,
      617., 618., 619., 620., 619., 620., 621., 622., 621., 622., 623., 624.,
      625., 626., 627., 628., 627., 628., 629., 630., 629., 630., 631., 632.,
      631., 632., 633., 634., 647., 648., 649., 650., 649., 650., 651., 652.,
      651., 652., 653., 654., 653., 654., 655., 656., 657., 658., 659., 660.,
      659., 660., 661., 662., 661., 662., 663., 664., 663., 664., 665., 666.,
      663., 664., 665., 666., 665., 666., 667., 668., 667., 668., 669., 670.,
      669., 670., 671., 672., 673., 674., 675., 676., 675., 676., 677., 678.,
      677., 678., 679., 680., 679., 680., 681., 682., 679., 680., 681., 682.,
      681., 682., 683., 684., 683., 684., 685., 686., 685., 686., 687., 688.,
      689., 690., 691., 692., 691., 692., 693., 694., 693., 694., 695., 696.,
      695., 696., 697., 698., 695., 696., 697., 698., 697., 698., 699., 700.,
      699., 700., 701., 702., 701., 702., 703., 704., 705., 706., 707., 708.,
      707., 708., 709., 710., 709., 710., 711., 712., 711., 712., 713., 714.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 141., 142., 143., 144.,
      145., 146., 147., 148., 365., 366., 367., 368., 369., 370., 371., 372.,
      397., 398., 399., 400., 401., 402., 403., 404., 621., 622., 623., 624.,
      625., 626., 627., 628., 653., 654., 655., 656., 657., 658., 659., 660.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16.,   16.5,  17.,   17.5,  18.5,  19.5,  20.,   20.5,  21.,   20.5,
      21.,   21.5,  22.,   23.,   24.,   24.5,  25.,   25.5,  25.,   25.5,
      26.,   26.5,  27.5,  28.5,  29.,   29.5,  30.,   29.5,  30.,   30.5,
      31.,   32.,   33.,   33.5,  34.,   34.5,  38.5,  39.,   39.5,  40.,
      41.,   42.,   42.5,  43.,   43.5,  43.,   43.5,  44.,   44.5,  45.5,
      46.5,  47.,   47.5,  48.,   47.5,  48.,   48.5,  49.,   50.,   51.,
      51.5,  52.,   52.5,  52.,   52.5,  53.,   53.5,  54.5,  55.5,  56.,
      56.5,  57.,   88.,   88.5,  89.,   89.5,  90.5,  91.5,  92.,   92.5,
      93.,   92.5,  93.,   93.5,  94.,   95.,   96.,   96.5,  97.,   97.5,
      97.,   97.5,  98.,   98.5,  99.5,  100.5, 101.,  101.5, 102.,  101.5,
      102.,  102.5, 103.,  104.,  105.,  105.5, 106.,  106.5, 110.5, 111.,
      111.5, 112.,  113.,  114.,  114.5, 115.,  115.5, 115.,  115.5, 116.,
      116.5, 117.5, 118.5, 119.,  119.5, 120.,  119.5, 120.,  120.5, 121.,
      122.,  123.,  123.5, 124.,  124.5, 124.,  124.5, 125.,  125.5, 126.5,
      127.5, 128.,  128.5, 129.,  160.,  160.5, 161.,  161.5, 162.5, 163.5,
      164.,  164.5, 165.,  164.5, 165.,  165.5, 166.,  167.,  168.,  168.5,
      169.,  169.5, 169.,  169.5, 170.,  170.5, 171.5, 172.5, 173.,  173.5,
      174.,  173.5, 174.,  174.5, 175.,  176.,  177.,  177.5, 178.,  178.5,
      182.5, 183.,  183.5, 184.,  185.,  186.,  186.5, 187.,  187.5, 187.,
      187.5, 188.,  188.5, 189.5, 190.5, 191.,  191.5, 192.,  191.5, 192.,
      192.5, 193.,  194.,  195.,  195.5, 196.,  196.5, 196.,  196.5, 197.,
      197.5, 198.5, 199.5, 200.,  200.5, 201.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31.,  32.,  33.,  40.,  41.,  42.,
                                         103., 104., 105., 112., 113., 114.,
                                         175., 176., 177., 184., 185., 186.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  32.,  33.,  33.,  34.,  34.,  35.,  36.,  37.,  38.,  39.,
      39.,  40.,  40.,  41.,  41.,  42.,  40.,  41.,  41.,  42.,  42.,  43.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  49.,  49.,  50.,  50.,  51.,
      49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,  54.,  55.,  56.,  57.,
      57.,  58.,  58.,  59.,  59.,  60.,  58.,  59.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  68.,  69.,
      76.,  77.,  77.,  78.,  78.,  79.,  79.,  80.,  81.,  82.,  83.,  84.,
      84.,  85.,  85.,  86.,  86.,  87.,  85.,  86.,  86.,  87.,  87.,  88.,
      88.,  89.,  90.,  91.,  92.,  93.,  93.,  94.,  94.,  95.,  95.,  96.,
      94.,  95.,  95.,  96.,  96.,  97.,  97.,  98.,  99.,  100., 101., 102.,
      102., 103., 103., 104., 104., 105., 103., 104., 104., 105., 105., 106.,
      106., 107., 108., 109., 110., 111., 111., 112., 112., 113., 113., 114.,
      175., 176., 176., 177., 177., 178., 178., 179., 180., 181., 182., 183.,
      183., 184., 184., 185., 185., 186., 184., 185., 185., 186., 186., 187.,
      187., 188., 189., 190., 191., 192., 192., 193., 193., 194., 194., 195.,
      193., 194., 194., 195., 195., 196., 196., 197., 198., 199., 200., 201.,
      201., 202., 202., 203., 203., 204., 202., 203., 203., 204., 204., 205.,
      205., 206., 207., 208., 209., 210., 210., 211., 211., 212., 212., 213.,
      220., 221., 221., 222., 222., 223., 223., 224., 225., 226., 227., 228.,
      228., 229., 229., 230., 230., 231., 229., 230., 230., 231., 231., 232.,
      232., 233., 234., 235., 236., 237., 237., 238., 238., 239., 239., 240.,
      238., 239., 239., 240., 240., 241., 241., 242., 243., 244., 245., 246.,
      246., 247., 247., 248., 248., 249., 247., 248., 248., 249., 249., 250.,
      250., 251., 252., 253., 254., 255., 255., 256., 256., 257., 257., 258.,
      319., 320., 320., 321., 321., 322., 322., 323., 324., 325., 326., 327.,
      327., 328., 328., 329., 329., 330., 328., 329., 329., 330., 330., 331.,
      331., 332., 333., 334., 335., 336., 336., 337., 337., 338., 338., 339.,
      337., 338., 338., 339., 339., 340., 340., 341., 342., 343., 344., 345.,
      345., 346., 346., 347., 347., 348., 346., 347., 347., 348., 348., 349.,
      349., 350., 351., 352., 353., 354., 354., 355., 355., 356., 356., 357.,
      364., 365., 365., 366., 366., 367., 367., 368., 369., 370., 371., 372.,
      372., 373., 373., 374., 374., 375., 373., 374., 374., 375., 375., 376.,
      376., 377., 378., 379., 380., 381., 381., 382., 382., 383., 383., 384.,
      382., 383., 383., 384., 384., 385., 385., 386., 387., 388., 389., 390.,
      390., 391., 391., 392., 392., 393., 391., 392., 392., 393., 393., 394.,
      394., 395., 396., 397., 398., 399., 399., 400., 400., 401., 401., 402.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  79.,  80.,  81.,  82.,  83.,  84.,
      205., 206., 207., 208., 209., 210., 223., 224., 225., 226., 227., 228.,
      349., 350., 351., 352., 353., 354., 367., 368., 369., 370., 371., 372.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  97.,  98.,  97.,  98.,  99.,  100., 99.,  100., 101., 102.,
      97.,  98.,  99.,  100., 99.,  100., 101., 102., 101., 102., 103., 104.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 113., 114.,
      113., 114., 115., 116., 115., 116., 117., 118., 117., 118., 119., 120.,
      115., 116., 117., 118., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 135., 136., 137., 138.,
      151., 152., 153., 154., 153., 154., 155., 156., 155., 156., 157., 158.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      167., 168., 169., 170., 169., 170., 171., 172., 171., 172., 173., 174.,
      169., 170., 171., 172., 171., 172., 173., 174., 173., 174., 175., 176.,
      175., 176., 177., 178., 179., 180., 181., 182., 183., 184., 185., 186.,
      185., 186., 187., 188., 187., 188., 189., 190., 189., 190., 191., 192.,
      187., 188., 189., 190., 189., 190., 191., 192., 191., 192., 193., 194.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      203., 204., 205., 206., 205., 206., 207., 208., 207., 208., 209., 210.,
      205., 206., 207., 208., 207., 208., 209., 210., 209., 210., 211., 212.,
      211., 212., 213., 214., 215., 216., 217., 218., 219., 220., 221., 222.,
      221., 222., 223., 224., 223., 224., 225., 226., 225., 226., 227., 228.,
      349., 350., 351., 352., 351., 352., 353., 354., 353., 354., 355., 356.,
      355., 356., 357., 358., 359., 360., 361., 362., 363., 364., 365., 366.,
      365., 366., 367., 368., 367., 368., 369., 370., 369., 370., 371., 372.,
      367., 368., 369., 370., 369., 370., 371., 372., 371., 372., 373., 374.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      383., 384., 385., 386., 385., 386., 387., 388., 387., 388., 389., 390.,
      385., 386., 387., 388., 387., 388., 389., 390., 389., 390., 391., 392.,
      391., 392., 393., 394., 395., 396., 397., 398., 399., 400., 401., 402.,
      401., 402., 403., 404., 403., 404., 405., 406., 405., 406., 407., 408.,
      403., 404., 405., 406., 405., 406., 407., 408., 407., 408., 409., 410.,
      409., 410., 411., 412., 413., 414., 415., 416., 417., 418., 419., 420.,
      419., 420., 421., 422., 421., 422., 423., 424., 423., 424., 425., 426.,
      439., 440., 441., 442., 441., 442., 443., 444., 443., 444., 445., 446.,
      445., 446., 447., 448., 449., 450., 451., 452., 453., 454., 455., 456.,
      455., 456., 457., 458., 457., 458., 459., 460., 459., 460., 461., 462.,
      457., 458., 459., 460., 459., 460., 461., 462., 461., 462., 463., 464.,
      463., 464., 465., 466., 467., 468., 469., 470., 471., 472., 473., 474.,
      473., 474., 475., 476., 475., 476., 477., 478., 477., 478., 479., 480.,
      475., 476., 477., 478., 477., 478., 479., 480., 479., 480., 481., 482.,
      481., 482., 483., 484., 485., 486., 487., 488., 489., 490., 491., 492.,
      491., 492., 493., 494., 493., 494., 495., 496., 495., 496., 497., 498.,
      493., 494., 495., 496., 495., 496., 497., 498., 497., 498., 499., 500.,
      499., 500., 501., 502., 503., 504., 505., 506., 507., 508., 509., 510.,
      509., 510., 511., 512., 511., 512., 513., 514., 513., 514., 515., 516.,
      637., 638., 639., 640., 639., 640., 641., 642., 641., 642., 643., 644.,
      643., 644., 645., 646., 647., 648., 649., 650., 651., 652., 653., 654.,
      653., 654., 655., 656., 655., 656., 657., 658., 657., 658., 659., 660.,
      655., 656., 657., 658., 657., 658., 659., 660., 659., 660., 661., 662.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,
      671., 672., 673., 674., 673., 674., 675., 676., 675., 676., 677., 678.,
      673., 674., 675., 676., 675., 676., 677., 678., 677., 678., 679., 680.,
      679., 680., 681., 682., 683., 684., 685., 686., 687., 688., 689., 690.,
      689., 690., 691., 692., 691., 692., 693., 694., 693., 694., 695., 696.,
      691., 692., 693., 694., 693., 694., 695., 696., 695., 696., 697., 698.,
      697., 698., 699., 700., 701., 702., 703., 704., 705., 706., 707., 708.,
      707., 708., 709., 710., 709., 710., 711., 712., 711., 712., 713., 714.,
      727., 728., 729., 730., 729., 730., 731., 732., 731., 732., 733., 734.,
      733., 734., 735., 736., 737., 738., 739., 740., 741., 742., 743., 744.,
      743., 744., 745., 746., 745., 746., 747., 748., 747., 748., 749., 750.,
      745., 746., 747., 748., 747., 748., 749., 750., 749., 750., 751., 752.,
      751., 752., 753., 754., 755., 756., 757., 758., 759., 760., 761., 762.,
      761., 762., 763., 764., 763., 764., 765., 766., 765., 766., 767., 768.,
      763., 764., 765., 766., 765., 766., 767., 768., 767., 768., 769., 770.,
      769., 770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,
      779., 780., 781., 782., 781., 782., 783., 784., 783., 784., 785., 786.,
      781., 782., 783., 784., 783., 784., 785., 786., 785., 786., 787., 788.,
      787., 788., 789., 790., 791., 792., 793., 794., 795., 796., 797., 798.,
      797., 798., 799., 800., 799., 800., 801., 802., 801., 802., 803., 804.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      409., 410., 411., 412., 413., 414., 415., 416., 417., 418., 419., 420.,
      445., 446., 447., 448., 449., 450., 451., 452., 453., 454., 455., 456.,
      697., 698., 699., 700., 701., 702., 703., 704., 705., 706., 707., 708.,
      733., 734., 735., 736., 737., 738., 739., 740., 741., 742., 743., 744.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5,  18.,  18.5,  19.,  20.,  21.,  22.,  22.5,  23.,  23.5,
      22.5,  23.,  23.5,  24.,  25.,  26.,  27.,  27.5,  28.,  28.5,
      27.5,  28.,  28.5,  29.,  30.,  31.,  32.,  32.5,  33.,  33.5,
      32.5,  33.,  33.5,  34.,  35.,  36.,  37.,  37.5,  38.,  38.5,
      42.5,  43.,  43.5,  44.,  45.,  46.,  47.,  47.5,  48.,  48.5,
      47.5,  48.,  48.5,  49.,  50.,  51.,  52.,  52.5,  53.,  53.5,
      52.5,  53.,  53.5,  54.,  55.,  56.,  57.,  57.5,  58.,  58.5,
      57.5,  58.,  58.5,  59.,  60.,  61.,  62.,  62.5,  63.,  63.5,
      97.5,  98.,  98.5,  99.,  100., 101., 102., 102.5, 103., 103.5,
      102.5, 103., 103.5, 104., 105., 106., 107., 107.5, 108., 108.5,
      107.5, 108., 108.5, 109., 110., 111., 112., 112.5, 113., 113.5,
      112.5, 113., 113.5, 114., 115., 116., 117., 117.5, 118., 118.5,
      122.5, 123., 123.5, 124., 125., 126., 127., 127.5, 128., 128.5,
      127.5, 128., 128.5, 129., 130., 131., 132., 132.5, 133., 133.5,
      132.5, 133., 133.5, 134., 135., 136., 137., 137.5, 138., 138.5,
      137.5, 138., 138.5, 139., 140., 141., 142., 142.5, 143., 143.5,
      177.5, 178., 178.5, 179., 180., 181., 182., 182.5, 183., 183.5,
      182.5, 183., 183.5, 184., 185., 186., 187., 187.5, 188., 188.5,
      187.5, 188., 188.5, 189., 190., 191., 192., 192.5, 193., 193.5,
      192.5, 193., 193.5, 194., 195., 196., 197., 197.5, 198., 198.5,
      202.5, 203., 203.5, 204., 205., 206., 207., 207.5, 208., 208.5,
      207.5, 208., 208.5, 209., 210., 211., 212., 212.5, 213., 213.5,
      212.5, 213., 213.5, 214., 215., 216., 217., 217.5, 218., 218.5,
      217.5, 218., 218.5, 219., 220., 221., 222., 222.5, 223., 223.5};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  36.,  37.,  44.,  45.,  46.,  47.,  114., 115., 116., 117.,
      124., 125., 126., 127., 194., 195., 196., 197., 204., 205., 206., 207.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  35.,  36.,  36.,  37.,  37.,  38.,  39.,  40.,  41.,  42.,
      43.,  44.,  44.,  45.,  45.,  46.,  46.,  47.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  54.,  55.,
      55.,  56.,  56.,  57.,  54.,  55.,  55.,  56.,  56.,  57.,  57.,  58.,
      59.,  60.,  61.,  62.,  63.,  64.,  64.,  65.,  65.,  66.,  66.,  67.,
      64.,  65.,  65.,  66.,  66.,  67.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  94.,  95.,
      95.,  96.,  96.,  97.,  94.,  95.,  95.,  96.,  96.,  97.,  97.,  98.,
      99.,  100., 101., 102., 103., 104., 104., 105., 105., 106., 106., 107.,
      104., 105., 105., 106., 106., 107., 107., 108., 109., 110., 111., 112.,
      113., 114., 114., 115., 115., 116., 116., 117., 114., 115., 115., 116.,
      116., 117., 117., 118., 119., 120., 121., 122., 123., 124., 124., 125.,
      125., 126., 126., 127., 194., 195., 195., 196., 196., 197., 197., 198.,
      199., 200., 201., 202., 203., 204., 204., 205., 205., 206., 206., 207.,
      204., 205., 205., 206., 206., 207., 207., 208., 209., 210., 211., 212.,
      213., 214., 214., 215., 215., 216., 216., 217., 214., 215., 215., 216.,
      216., 217., 217., 218., 219., 220., 221., 222., 223., 224., 224., 225.,
      225., 226., 226., 227., 224., 225., 225., 226., 226., 227., 227., 228.,
      229., 230., 231., 232., 233., 234., 234., 235., 235., 236., 236., 237.,
      244., 245., 245., 246., 246., 247., 247., 248., 249., 250., 251., 252.,
      253., 254., 254., 255., 255., 256., 256., 257., 254., 255., 255., 256.,
      256., 257., 257., 258., 259., 260., 261., 262., 263., 264., 264., 265.,
      265., 266., 266., 267., 264., 265., 265., 266., 266., 267., 267., 268.,
      269., 270., 271., 272., 273., 274., 274., 275., 275., 276., 276., 277.,
      274., 275., 275., 276., 276., 277., 277., 278., 279., 280., 281., 282.,
      283., 284., 284., 285., 285., 286., 286., 287., 354., 355., 355., 356.,
      356., 357., 357., 358., 359., 360., 361., 362., 363., 364., 364., 365.,
      365., 366., 366., 367., 364., 365., 365., 366., 366., 367., 367., 368.,
      369., 370., 371., 372., 373., 374., 374., 375., 375., 376., 376., 377.,
      374., 375., 375., 376., 376., 377., 377., 378., 379., 380., 381., 382.,
      383., 384., 384., 385., 385., 386., 386., 387., 384., 385., 385., 386.,
      386., 387., 387., 388., 389., 390., 391., 392., 393., 394., 394., 395.,
      395., 396., 396., 397., 404., 405., 405., 406., 406., 407., 407., 408.,
      409., 410., 411., 412., 413., 414., 414., 415., 415., 416., 416., 417.,
      414., 415., 415., 416., 416., 417., 417., 418., 419., 420., 421., 422.,
      423., 424., 424., 425., 425., 426., 426., 427., 424., 425., 425., 426.,
      426., 427., 427., 428., 429., 430., 431., 432., 433., 434., 434., 435.,
      435., 436., 436., 437., 434., 435., 435., 436., 436., 437., 437., 438.,
      439., 440., 441., 442., 443., 444., 444., 445., 445., 446., 446., 447.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  227., 228., 229., 230., 231., 232., 233., 234.,
      247., 248., 249., 250., 251., 252., 253., 254., 387., 388., 389., 390.,
      391., 392., 393., 394., 407., 408., 409., 410., 411., 412., 413., 414.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 107., 108., 109., 110.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      127., 128., 129., 130., 129., 130., 131., 132., 131., 132., 133., 134.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 187., 188., 189., 190.,
      189., 190., 191., 192., 191., 192., 193., 194., 187., 188., 189., 190.,
      189., 190., 191., 192., 191., 192., 193., 194., 193., 194., 195., 196.,
      197., 198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,
      207., 208., 209., 210., 209., 210., 211., 212., 211., 212., 213., 214.,
      207., 208., 209., 210., 209., 210., 211., 212., 211., 212., 213., 214.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      225., 226., 227., 228., 227., 228., 229., 230., 229., 230., 231., 232.,
      231., 232., 233., 234., 227., 228., 229., 230., 229., 230., 231., 232.,
      231., 232., 233., 234., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 247., 248., 249., 250.,
      249., 250., 251., 252., 251., 252., 253., 254., 387., 388., 389., 390.,
      389., 390., 391., 392., 391., 392., 393., 394., 393., 394., 395., 396.,
      397., 398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,
      407., 408., 409., 410., 409., 410., 411., 412., 411., 412., 413., 414.,
      407., 408., 409., 410., 409., 410., 411., 412., 411., 412., 413., 414.,
      413., 414., 415., 416., 417., 418., 419., 420., 421., 422., 423., 424.,
      425., 426., 427., 428., 427., 428., 429., 430., 429., 430., 431., 432.,
      431., 432., 433., 434., 427., 428., 429., 430., 429., 430., 431., 432.,
      431., 432., 433., 434., 433., 434., 435., 436., 437., 438., 439., 440.,
      441., 442., 443., 444., 445., 446., 447., 448., 447., 448., 449., 450.,
      449., 450., 451., 452., 451., 452., 453., 454., 447., 448., 449., 450.,
      449., 450., 451., 452., 451., 452., 453., 454., 453., 454., 455., 456.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      467., 468., 469., 470., 469., 470., 471., 472., 471., 472., 473., 474.,
      487., 488., 489., 490., 489., 490., 491., 492., 491., 492., 493., 494.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 507., 508., 509., 510., 509., 510., 511., 512.,
      511., 512., 513., 514., 507., 508., 509., 510., 509., 510., 511., 512.,
      511., 512., 513., 514., 513., 514., 515., 516., 517., 518., 519., 520.,
      521., 522., 523., 524., 525., 526., 527., 528., 527., 528., 529., 530.,
      529., 530., 531., 532., 531., 532., 533., 534., 527., 528., 529., 530.,
      529., 530., 531., 532., 531., 532., 533., 534., 533., 534., 535., 536.,
      537., 538., 539., 540., 541., 542., 543., 544., 545., 546., 547., 548.,
      547., 548., 549., 550., 549., 550., 551., 552., 551., 552., 553., 554.,
      547., 548., 549., 550., 549., 550., 551., 552., 551., 552., 553., 554.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 567., 568., 569., 570., 569., 570., 571., 572.,
      571., 572., 573., 574., 707., 708., 709., 710., 709., 710., 711., 712.,
      711., 712., 713., 714., 713., 714., 715., 716., 717., 718., 719., 720.,
      721., 722., 723., 724., 725., 726., 727., 728., 727., 728., 729., 730.,
      729., 730., 731., 732., 731., 732., 733., 734., 727., 728., 729., 730.,
      729., 730., 731., 732., 731., 732., 733., 734., 733., 734., 735., 736.,
      737., 738., 739., 740., 741., 742., 743., 744., 745., 746., 747., 748.,
      747., 748., 749., 750., 749., 750., 751., 752., 751., 752., 753., 754.,
      747., 748., 749., 750., 749., 750., 751., 752., 751., 752., 753., 754.,
      753., 754., 755., 756., 757., 758., 759., 760., 761., 762., 763., 764.,
      765., 766., 767., 768., 767., 768., 769., 770., 769., 770., 771., 772.,
      771., 772., 773., 774., 767., 768., 769., 770., 769., 770., 771., 772.,
      771., 772., 773., 774., 773., 774., 775., 776., 777., 778., 779., 780.,
      781., 782., 783., 784., 785., 786., 787., 788., 787., 788., 789., 790.,
      789., 790., 791., 792., 791., 792., 793., 794., 807., 808., 809., 810.,
      809., 810., 811., 812., 811., 812., 813., 814., 813., 814., 815., 816.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.,
      827., 828., 829., 830., 829., 830., 831., 832., 831., 832., 833., 834.,
      827., 828., 829., 830., 829., 830., 831., 832., 831., 832., 833., 834.,
      833., 834., 835., 836., 837., 838., 839., 840., 841., 842., 843., 844.,
      845., 846., 847., 848., 847., 848., 849., 850., 849., 850., 851., 852.,
      851., 852., 853., 854., 847., 848., 849., 850., 849., 850., 851., 852.,
      851., 852., 853., 854., 853., 854., 855., 856., 857., 858., 859., 860.,
      861., 862., 863., 864., 865., 866., 867., 868., 867., 868., 869., 870.,
      869., 870., 871., 872., 871., 872., 873., 874., 867., 868., 869., 870.,
      869., 870., 871., 872., 871., 872., 873., 874., 873., 874., 875., 876.,
      877., 878., 879., 880., 881., 882., 883., 884., 885., 886., 887., 888.,
      887., 888., 889., 890., 889., 890., 891., 892., 891., 892., 893., 894.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 453., 454., 455., 456.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 773., 774., 775., 776., 777., 778., 779., 780.,
      781., 782., 783., 784., 785., 786., 787., 788., 813., 814., 815., 816.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5,  15.,   15.5,  16.,   17.,   17.5,  18.,   18.5,  18.5,  19.,
      19.5,  20.,   21.,   21.5,  22.,   22.5,  22.5,  23.,   23.5,  24.,
      25.,   25.5,  26.,   26.5,  26.5,  27.,   27.5,  28.,   29.,   29.5,
      30.,   30.5,  34.5,  35.,   35.5,  36.,   37.,   37.5,  38.,   38.5,
      42.5,  43.,   43.5,  44.,   45.,   45.5,  46.,   46.5,  46.5,  47.,
      47.5,  48.,   49.,   49.5,  50.,   50.5,  50.5,  51.,   51.5,  52.,
      53.,   53.5,  54.,   54.5,  54.5,  55.,   55.5,  56.,   57.,   57.5,
      58.,   58.5,  86.5,  87.,   87.5,  88.,   89.,   89.5,  90.,   90.5,
      90.5,  91.,   91.5,  92.,   93.,   93.5,  94.,   94.5,  94.5,  95.,
      95.5,  96.,   97.,   97.5,  98.,   98.5,  98.5,  99.,   99.5,  100.,
      101.,  101.5, 102.,  102.5, 106.5, 107.,  107.5, 108.,  109.,  109.5,
      110.,  110.5, 114.5, 115.,  115.5, 116.,  117.,  117.5, 118.,  118.5,
      118.5, 119.,  119.5, 120.,  121.,  121.5, 122.,  122.5, 122.5, 123.,
      123.5, 124.,  125.,  125.5, 126.,  126.5, 126.5, 127.,  127.5, 128.,
      129.,  129.5, 130.,  130.5, 158.5, 159.,  159.5, 160.,  161.,  161.5,
      162.,  162.5, 162.5, 163.,  163.5, 164.,  165.,  165.5, 166.,  166.5,
      166.5, 167.,  167.5, 168.,  169.,  169.5, 170.,  170.5, 170.5, 171.,
      171.5, 172.,  173.,  173.5, 174.,  174.5, 178.5, 179.,  179.5, 180.,
      181.,  181.5, 182.,  182.5, 186.5, 187.,  187.5, 188.,  189.,  189.5,
      190.,  190.5, 190.5, 191.,  191.5, 192.,  193.,  193.5, 194.,  194.5,
      194.5, 195.,  195.5, 196.,  197.,  197.5, 198.,  198.5, 198.5, 199.,
      199.5, 200.,  201.,  201.5, 202.,  202.5};
  const std::array<int, 4> in_shape = {{3, 9, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28.,  29.,  36.,  37.,  44.,  45.,
                                         100., 101., 108., 109., 116., 117.,
                                         172., 173., 180., 181., 188., 189.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  29.,  30.,  30.,  31.,  31.,  32.,  33.,  34.,  34.,  35.,
      35.,  36.,  36.,  37.,  36.,  37.,  37.,  38.,  38.,  39.,  39.,  40.,
      41.,  42.,  42.,  43.,  43.,  44.,  44.,  45.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,
      52.,  53.,  53.,  54.,  54.,  55.,  55.,  56.,  57.,  58.,  58.,  59.,
      59.,  60.,  60.,  61.,  68.,  69.,  69.,  70.,  70.,  71.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  90.,  91.,  91.,  92.,  92.,  93.,
      92.,  93.,  93.,  94.,  94.,  95.,  95.,  96.,  97.,  98.,  98.,  99.,
      99.,  100., 100., 101., 100., 101., 101., 102., 102., 103., 103., 104.,
      105., 106., 106., 107., 107., 108., 108., 109., 108., 109., 109., 110.,
      110., 111., 111., 112., 113., 114., 114., 115., 115., 116., 116., 117.,
      172., 173., 173., 174., 174., 175., 175., 176., 177., 178., 178., 179.,
      179., 180., 180., 181., 180., 181., 181., 182., 182., 183., 183., 184.,
      185., 186., 186., 187., 187., 188., 188., 189., 188., 189., 189., 190.,
      190., 191., 191., 192., 193., 194., 194., 195., 195., 196., 196., 197.,
      196., 197., 197., 198., 198., 199., 199., 200., 201., 202., 202., 203.,
      203., 204., 204., 205., 212., 213., 213., 214., 214., 215., 215., 216.,
      217., 218., 218., 219., 219., 220., 220., 221., 228., 229., 229., 230.,
      230., 231., 231., 232., 233., 234., 234., 235., 235., 236., 236., 237.,
      236., 237., 237., 238., 238., 239., 239., 240., 241., 242., 242., 243.,
      243., 244., 244., 245., 244., 245., 245., 246., 246., 247., 247., 248.,
      249., 250., 250., 251., 251., 252., 252., 253., 252., 253., 253., 254.,
      254., 255., 255., 256., 257., 258., 258., 259., 259., 260., 260., 261.,
      316., 317., 317., 318., 318., 319., 319., 320., 321., 322., 322., 323.,
      323., 324., 324., 325., 324., 325., 325., 326., 326., 327., 327., 328.,
      329., 330., 330., 331., 331., 332., 332., 333., 332., 333., 333., 334.,
      334., 335., 335., 336., 337., 338., 338., 339., 339., 340., 340., 341.,
      340., 341., 341., 342., 342., 343., 343., 344., 345., 346., 346., 347.,
      347., 348., 348., 349., 356., 357., 357., 358., 358., 359., 359., 360.,
      361., 362., 362., 363., 363., 364., 364., 365., 372., 373., 373., 374.,
      374., 375., 375., 376., 377., 378., 378., 379., 379., 380., 380., 381.,
      380., 381., 381., 382., 382., 383., 383., 384., 385., 386., 386., 387.,
      387., 388., 388., 389., 388., 389., 389., 390., 390., 391., 391., 392.,
      393., 394., 394., 395., 395., 396., 396., 397., 396., 397., 397., 398.,
      398., 399., 399., 400., 401., 402., 402., 403., 403., 404., 404., 405.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  71.,  72.,  73.,  74.,  87.,  88.,  89.,  90.,
      199., 200., 201., 202., 215., 216., 217., 218., 231., 232., 233., 234.,
      343., 344., 345., 346., 359., 360., 361., 362., 375., 376., 377., 378.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  67.,  68.,  69.,  70.,
      69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,  85.,  86.,  87.,  88.,
      87.,  88.,  89.,  90.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      99.,  100., 101., 102., 101., 102., 103., 104., 103., 104., 105., 106.,
      103., 104., 105., 106., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 113., 114., 115., 116., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 135., 136., 137., 138.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 181., 182., 181., 182., 183., 184., 183., 184., 185., 186.,
      183., 184., 185., 186., 185., 186., 187., 188., 187., 188., 189., 190.,
      189., 190., 191., 192., 193., 194., 195., 196., 195., 196., 197., 198.,
      197., 198., 199., 200., 199., 200., 201., 202., 199., 200., 201., 202.,
      201., 202., 203., 204., 203., 204., 205., 206., 205., 206., 207., 208.,
      209., 210., 211., 212., 211., 212., 213., 214., 213., 214., 215., 216.,
      215., 216., 217., 218., 215., 216., 217., 218., 217., 218., 219., 220.,
      219., 220., 221., 222., 221., 222., 223., 224., 225., 226., 227., 228.,
      227., 228., 229., 230., 229., 230., 231., 232., 231., 232., 233., 234.,
      343., 344., 345., 346., 345., 346., 347., 348., 347., 348., 349., 350.,
      349., 350., 351., 352., 353., 354., 355., 356., 355., 356., 357., 358.,
      357., 358., 359., 360., 359., 360., 361., 362., 359., 360., 361., 362.,
      361., 362., 363., 364., 363., 364., 365., 366., 365., 366., 367., 368.,
      369., 370., 371., 372., 371., 372., 373., 374., 373., 374., 375., 376.,
      375., 376., 377., 378., 375., 376., 377., 378., 377., 378., 379., 380.,
      379., 380., 381., 382., 381., 382., 383., 384., 385., 386., 387., 388.,
      387., 388., 389., 390., 389., 390., 391., 392., 391., 392., 393., 394.,
      391., 392., 393., 394., 393., 394., 395., 396., 395., 396., 397., 398.,
      397., 398., 399., 400., 401., 402., 403., 404., 403., 404., 405., 406.,
      405., 406., 407., 408., 407., 408., 409., 410., 423., 424., 425., 426.,
      425., 426., 427., 428., 427., 428., 429., 430., 429., 430., 431., 432.,
      433., 434., 435., 436., 435., 436., 437., 438., 437., 438., 439., 440.,
      439., 440., 441., 442., 455., 456., 457., 458., 457., 458., 459., 460.,
      459., 460., 461., 462., 461., 462., 463., 464., 465., 466., 467., 468.,
      467., 468., 469., 470., 469., 470., 471., 472., 471., 472., 473., 474.,
      471., 472., 473., 474., 473., 474., 475., 476., 475., 476., 477., 478.,
      477., 478., 479., 480., 481., 482., 483., 484., 483., 484., 485., 486.,
      485., 486., 487., 488., 487., 488., 489., 490., 487., 488., 489., 490.,
      489., 490., 491., 492., 491., 492., 493., 494., 493., 494., 495., 496.,
      497., 498., 499., 500., 499., 500., 501., 502., 501., 502., 503., 504.,
      503., 504., 505., 506., 503., 504., 505., 506., 505., 506., 507., 508.,
      507., 508., 509., 510., 509., 510., 511., 512., 513., 514., 515., 516.,
      515., 516., 517., 518., 517., 518., 519., 520., 519., 520., 521., 522.,
      631., 632., 633., 634., 633., 634., 635., 636., 635., 636., 637., 638.,
      637., 638., 639., 640., 641., 642., 643., 644., 643., 644., 645., 646.,
      645., 646., 647., 648., 647., 648., 649., 650., 647., 648., 649., 650.,
      649., 650., 651., 652., 651., 652., 653., 654., 653., 654., 655., 656.,
      657., 658., 659., 660., 659., 660., 661., 662., 661., 662., 663., 664.,
      663., 664., 665., 666., 663., 664., 665., 666., 665., 666., 667., 668.,
      667., 668., 669., 670., 669., 670., 671., 672., 673., 674., 675., 676.,
      675., 676., 677., 678., 677., 678., 679., 680., 679., 680., 681., 682.,
      679., 680., 681., 682., 681., 682., 683., 684., 683., 684., 685., 686.,
      685., 686., 687., 688., 689., 690., 691., 692., 691., 692., 693., 694.,
      693., 694., 695., 696., 695., 696., 697., 698., 711., 712., 713., 714.,
      713., 714., 715., 716., 715., 716., 717., 718., 717., 718., 719., 720.,
      721., 722., 723., 724., 723., 724., 725., 726., 725., 726., 727., 728.,
      727., 728., 729., 730., 743., 744., 745., 746., 745., 746., 747., 748.,
      747., 748., 749., 750., 749., 750., 751., 752., 753., 754., 755., 756.,
      755., 756., 757., 758., 757., 758., 759., 760., 759., 760., 761., 762.,
      759., 760., 761., 762., 761., 762., 763., 764., 763., 764., 765., 766.,
      765., 766., 767., 768., 769., 770., 771., 772., 771., 772., 773., 774.,
      773., 774., 775., 776., 775., 776., 777., 778., 775., 776., 777., 778.,
      777., 778., 779., 780., 779., 780., 781., 782., 781., 782., 783., 784.,
      785., 786., 787., 788., 787., 788., 789., 790., 789., 790., 791., 792.,
      791., 792., 793., 794., 791., 792., 793., 794., 793., 794., 795., 796.,
      795., 796., 797., 798., 797., 798., 799., 800., 801., 802., 803., 804.,
      803., 804., 805., 806., 805., 806., 807., 808., 807., 808., 809., 810.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 141., 142., 143., 144.,
      145., 146., 147., 148., 173., 174., 175., 176., 177., 178., 179., 180.,
      397., 398., 399., 400., 401., 402., 403., 404., 429., 430., 431., 432.,
      433., 434., 435., 436., 461., 462., 463., 464., 465., 466., 467., 468.,
      685., 686., 687., 688., 689., 690., 691., 692., 717., 718., 719., 720.,
      721., 722., 723., 724., 749., 750., 751., 752., 753., 754., 755., 756.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16.,   16.5,  17.,   17.5,  18.5,  19.5,  20.,   20.5,  21.,   20.5,
      21.,   21.5,  22.,   23.,   24.,   24.5,  25.,   25.5,  25.,   25.5,
      26.,   26.5,  27.5,  28.5,  29.,   29.5,  30.,   29.5,  30.,   30.5,
      31.,   32.,   33.,   33.5,  34.,   34.5,  38.5,  39.,   39.5,  40.,
      41.,   42.,   42.5,  43.,   43.5,  47.5,  48.,   48.5,  49.,   50.,
      51.,   51.5,  52.,   52.5,  52.,   52.5,  53.,   53.5,  54.5,  55.5,
      56.,   56.5,  57.,   56.5,  57.,   57.5,  58.,   59.,   60.,   60.5,
      61.,   61.5,  61.,   61.5,  62.,   62.5,  63.5,  64.5,  65.,   65.5,
      66.,   97.,   97.5,  98.,   98.5,  99.5,  100.5, 101.,  101.5, 102.,
      101.5, 102.,  102.5, 103.,  104.,  105.,  105.5, 106.,  106.5, 106.,
      106.5, 107.,  107.5, 108.5, 109.5, 110.,  110.5, 111.,  110.5, 111.,
      111.5, 112.,  113.,  114.,  114.5, 115.,  115.5, 119.5, 120.,  120.5,
      121.,  122.,  123.,  123.5, 124.,  124.5, 128.5, 129.,  129.5, 130.,
      131.,  132.,  132.5, 133.,  133.5, 133.,  133.5, 134.,  134.5, 135.5,
      136.5, 137.,  137.5, 138.,  137.5, 138.,  138.5, 139.,  140.,  141.,
      141.5, 142.,  142.5, 142.,  142.5, 143.,  143.5, 144.5, 145.5, 146.,
      146.5, 147.,  178.,  178.5, 179.,  179.5, 180.5, 181.5, 182.,  182.5,
      183.,  182.5, 183.,  183.5, 184.,  185.,  186.,  186.5, 187.,  187.5,
      187.,  187.5, 188.,  188.5, 189.5, 190.5, 191.,  191.5, 192.,  191.5,
      192.,  192.5, 193.,  194.,  195.,  195.5, 196.,  196.5, 200.5, 201.,
      201.5, 202.,  203.,  204.,  204.5, 205.,  205.5, 209.5, 210.,  210.5,
      211.,  212.,  213.,  213.5, 214.,  214.5, 214.,  214.5, 215.,  215.5,
      216.5, 217.5, 218.,  218.5, 219.,  218.5, 219.,  219.5, 220.,  221.,
      222.,  222.5, 223.,  223.5, 223.,  223.5, 224.,  224.5, 225.5, 226.5,
      227.,  227.5, 228.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  33.,  40.,  41.,  42.,  49.,  50.,  51.,
      112., 113., 114., 121., 122., 123., 130., 131., 132.,
      193., 194., 195., 202., 203., 204., 211., 212., 213.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  32.,  33.,  33.,  34.,  34.,  35.,  36.,  37.,  38.,  39.,
      39.,  40.,  40.,  41.,  41.,  42.,  40.,  41.,  41.,  42.,  42.,  43.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  49.,  49.,  50.,  50.,  51.,
      49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,  54.,  55.,  56.,  57.,
      57.,  58.,  58.,  59.,  59.,  60.,  58.,  59.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  68.,  69.,
      76.,  77.,  77.,  78.,  78.,  79.,  79.,  80.,  81.,  82.,  83.,  84.,
      84.,  85.,  85.,  86.,  86.,  87.,  94.,  95.,  95.,  96.,  96.,  97.,
      97.,  98.,  99.,  100., 101., 102., 102., 103., 103., 104., 104., 105.,
      103., 104., 104., 105., 105., 106., 106., 107., 108., 109., 110., 111.,
      111., 112., 112., 113., 113., 114., 112., 113., 113., 114., 114., 115.,
      115., 116., 117., 118., 119., 120., 120., 121., 121., 122., 122., 123.,
      121., 122., 122., 123., 123., 124., 124., 125., 126., 127., 128., 129.,
      129., 130., 130., 131., 131., 132., 193., 194., 194., 195., 195., 196.,
      196., 197., 198., 199., 200., 201., 201., 202., 202., 203., 203., 204.,
      202., 203., 203., 204., 204., 205., 205., 206., 207., 208., 209., 210.,
      210., 211., 211., 212., 212., 213., 211., 212., 212., 213., 213., 214.,
      214., 215., 216., 217., 218., 219., 219., 220., 220., 221., 221., 222.,
      220., 221., 221., 222., 222., 223., 223., 224., 225., 226., 227., 228.,
      228., 229., 229., 230., 230., 231., 238., 239., 239., 240., 240., 241.,
      241., 242., 243., 244., 245., 246., 246., 247., 247., 248., 248., 249.,
      256., 257., 257., 258., 258., 259., 259., 260., 261., 262., 263., 264.,
      264., 265., 265., 266., 266., 267., 265., 266., 266., 267., 267., 268.,
      268., 269., 270., 271., 272., 273., 273., 274., 274., 275., 275., 276.,
      274., 275., 275., 276., 276., 277., 277., 278., 279., 280., 281., 282.,
      282., 283., 283., 284., 284., 285., 283., 284., 284., 285., 285., 286.,
      286., 287., 288., 289., 290., 291., 291., 292., 292., 293., 293., 294.,
      355., 356., 356., 357., 357., 358., 358., 359., 360., 361., 362., 363.,
      363., 364., 364., 365., 365., 366., 364., 365., 365., 366., 366., 367.,
      367., 368., 369., 370., 371., 372., 372., 373., 373., 374., 374., 375.,
      373., 374., 374., 375., 375., 376., 376., 377., 378., 379., 380., 381.,
      381., 382., 382., 383., 383., 384., 382., 383., 383., 384., 384., 385.,
      385., 386., 387., 388., 389., 390., 390., 391., 391., 392., 392., 393.,
      400., 401., 401., 402., 402., 403., 403., 404., 405., 406., 407., 408.,
      408., 409., 409., 410., 410., 411., 418., 419., 419., 420., 420., 421.,
      421., 422., 423., 424., 425., 426., 426., 427., 427., 428., 428., 429.,
      427., 428., 428., 429., 429., 430., 430., 431., 432., 433., 434., 435.,
      435., 436., 436., 437., 437., 438., 436., 437., 437., 438., 438., 439.,
      439., 440., 441., 442., 443., 444., 444., 445., 445., 446., 446., 447.,
      445., 446., 446., 447., 447., 448., 448., 449., 450., 451., 452., 453.,
      453., 454., 454., 455., 455., 456.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  79.,  80.,  81.,  82.,  83.,
      84.,  97.,  98.,  99.,  100., 101., 102., 223., 224., 225., 226.,
      227., 228., 241., 242., 243., 244., 245., 246., 259., 260., 261.,
      262., 263., 264., 385., 386., 387., 388., 389., 390., 403., 404.,
      405., 406., 407., 408., 421., 422., 423., 424., 425., 426.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  97.,  98.,  97.,  98.,  99.,  100., 99.,  100., 101., 102.,
      97.,  98.,  99.,  100., 99.,  100., 101., 102., 101., 102., 103., 104.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 113., 114.,
      113., 114., 115., 116., 115., 116., 117., 118., 117., 118., 119., 120.,
      115., 116., 117., 118., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 135., 136., 137., 138.,
      151., 152., 153., 154., 153., 154., 155., 156., 155., 156., 157., 158.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      167., 168., 169., 170., 169., 170., 171., 172., 171., 172., 173., 174.,
      187., 188., 189., 190., 189., 190., 191., 192., 191., 192., 193., 194.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      203., 204., 205., 206., 205., 206., 207., 208., 207., 208., 209., 210.,
      205., 206., 207., 208., 207., 208., 209., 210., 209., 210., 211., 212.,
      211., 212., 213., 214., 215., 216., 217., 218., 219., 220., 221., 222.,
      221., 222., 223., 224., 223., 224., 225., 226., 225., 226., 227., 228.,
      223., 224., 225., 226., 225., 226., 227., 228., 227., 228., 229., 230.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      239., 240., 241., 242., 241., 242., 243., 244., 243., 244., 245., 246.,
      241., 242., 243., 244., 243., 244., 245., 246., 245., 246., 247., 248.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 257., 258.,
      257., 258., 259., 260., 259., 260., 261., 262., 261., 262., 263., 264.,
      385., 386., 387., 388., 387., 388., 389., 390., 389., 390., 391., 392.,
      391., 392., 393., 394., 395., 396., 397., 398., 399., 400., 401., 402.,
      401., 402., 403., 404., 403., 404., 405., 406., 405., 406., 407., 408.,
      403., 404., 405., 406., 405., 406., 407., 408., 407., 408., 409., 410.,
      409., 410., 411., 412., 413., 414., 415., 416., 417., 418., 419., 420.,
      419., 420., 421., 422., 421., 422., 423., 424., 423., 424., 425., 426.,
      421., 422., 423., 424., 423., 424., 425., 426., 425., 426., 427., 428.,
      427., 428., 429., 430., 431., 432., 433., 434., 435., 436., 437., 438.,
      437., 438., 439., 440., 439., 440., 441., 442., 441., 442., 443., 444.,
      439., 440., 441., 442., 441., 442., 443., 444., 443., 444., 445., 446.,
      445., 446., 447., 448., 449., 450., 451., 452., 453., 454., 455., 456.,
      455., 456., 457., 458., 457., 458., 459., 460., 459., 460., 461., 462.,
      475., 476., 477., 478., 477., 478., 479., 480., 479., 480., 481., 482.,
      481., 482., 483., 484., 485., 486., 487., 488., 489., 490., 491., 492.,
      491., 492., 493., 494., 493., 494., 495., 496., 495., 496., 497., 498.,
      511., 512., 513., 514., 513., 514., 515., 516., 515., 516., 517., 518.,
      517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527., 528.,
      527., 528., 529., 530., 529., 530., 531., 532., 531., 532., 533., 534.,
      529., 530., 531., 532., 531., 532., 533., 534., 533., 534., 535., 536.,
      535., 536., 537., 538., 539., 540., 541., 542., 543., 544., 545., 546.,
      545., 546., 547., 548., 547., 548., 549., 550., 549., 550., 551., 552.,
      547., 548., 549., 550., 549., 550., 551., 552., 551., 552., 553., 554.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      563., 564., 565., 566., 565., 566., 567., 568., 567., 568., 569., 570.,
      565., 566., 567., 568., 567., 568., 569., 570., 569., 570., 571., 572.,
      571., 572., 573., 574., 575., 576., 577., 578., 579., 580., 581., 582.,
      581., 582., 583., 584., 583., 584., 585., 586., 585., 586., 587., 588.,
      709., 710., 711., 712., 711., 712., 713., 714., 713., 714., 715., 716.,
      715., 716., 717., 718., 719., 720., 721., 722., 723., 724., 725., 726.,
      725., 726., 727., 728., 727., 728., 729., 730., 729., 730., 731., 732.,
      727., 728., 729., 730., 729., 730., 731., 732., 731., 732., 733., 734.,
      733., 734., 735., 736., 737., 738., 739., 740., 741., 742., 743., 744.,
      743., 744., 745., 746., 745., 746., 747., 748., 747., 748., 749., 750.,
      745., 746., 747., 748., 747., 748., 749., 750., 749., 750., 751., 752.,
      751., 752., 753., 754., 755., 756., 757., 758., 759., 760., 761., 762.,
      761., 762., 763., 764., 763., 764., 765., 766., 765., 766., 767., 768.,
      763., 764., 765., 766., 765., 766., 767., 768., 767., 768., 769., 770.,
      769., 770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,
      779., 780., 781., 782., 781., 782., 783., 784., 783., 784., 785., 786.,
      799., 800., 801., 802., 801., 802., 803., 804., 803., 804., 805., 806.,
      805., 806., 807., 808., 809., 810., 811., 812., 813., 814., 815., 816.,
      815., 816., 817., 818., 817., 818., 819., 820., 819., 820., 821., 822.,
      835., 836., 837., 838., 837., 838., 839., 840., 839., 840., 841., 842.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.,
      851., 852., 853., 854., 853., 854., 855., 856., 855., 856., 857., 858.,
      853., 854., 855., 856., 855., 856., 857., 858., 857., 858., 859., 860.,
      859., 860., 861., 862., 863., 864., 865., 866., 867., 868., 869., 870.,
      869., 870., 871., 872., 871., 872., 873., 874., 873., 874., 875., 876.,
      871., 872., 873., 874., 873., 874., 875., 876., 875., 876., 877., 878.,
      877., 878., 879., 880., 881., 882., 883., 884., 885., 886., 887., 888.,
      887., 888., 889., 890., 889., 890., 891., 892., 891., 892., 893., 894.,
      889., 890., 891., 892., 891., 892., 893., 894., 893., 894., 895., 896.,
      895., 896., 897., 898., 899., 900., 901., 902., 903., 904., 905., 906.,
      905., 906., 907., 908., 907., 908., 909., 910., 909., 910., 911., 912.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      445., 446., 447., 448., 449., 450., 451., 452., 453., 454., 455., 456.,
      481., 482., 483., 484., 485., 486., 487., 488., 489., 490., 491., 492.,
      517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527., 528.,
      769., 770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,
      805., 806., 807., 808., 809., 810., 811., 812., 813., 814., 815., 816.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5,  18.,  18.5,  19.,  20.,  21.,  22.,  22.5,  23.,  23.5,
      22.5,  23.,  23.5,  24.,  25.,  26.,  27.,  27.5,  28.,  28.5,
      27.5,  28.,  28.5,  29.,  30.,  31.,  32.,  32.5,  33.,  33.5,
      32.5,  33.,  33.5,  34.,  35.,  36.,  37.,  37.5,  38.,  38.5,
      42.5,  43.,  43.5,  44.,  45.,  46.,  47.,  47.5,  48.,  48.5,
      52.5,  53.,  53.5,  54.,  55.,  56.,  57.,  57.5,  58.,  58.5,
      57.5,  58.,  58.5,  59.,  60.,  61.,  62.,  62.5,  63.,  63.5,
      62.5,  63.,  63.5,  64.,  65.,  66.,  67.,  67.5,  68.,  68.5,
      67.5,  68.,  68.5,  69.,  70.,  71.,  72.,  72.5,  73.,  73.5,
      107.5, 108., 108.5, 109., 110., 111., 112., 112.5, 113., 113.5,
      112.5, 113., 113.5, 114., 115., 116., 117., 117.5, 118., 118.5,
      117.5, 118., 118.5, 119., 120., 121., 122., 122.5, 123., 123.5,
      122.5, 123., 123.5, 124., 125., 126., 127., 127.5, 128., 128.5,
      132.5, 133., 133.5, 134., 135., 136., 137., 137.5, 138., 138.5,
      142.5, 143., 143.5, 144., 145., 146., 147., 147.5, 148., 148.5,
      147.5, 148., 148.5, 149., 150., 151., 152., 152.5, 153., 153.5,
      152.5, 153., 153.5, 154., 155., 156., 157., 157.5, 158., 158.5,
      157.5, 158., 158.5, 159., 160., 161., 162., 162.5, 163., 163.5,
      197.5, 198., 198.5, 199., 200., 201., 202., 202.5, 203., 203.5,
      202.5, 203., 203.5, 204., 205., 206., 207., 207.5, 208., 208.5,
      207.5, 208., 208.5, 209., 210., 211., 212., 212.5, 213., 213.5,
      212.5, 213., 213.5, 214., 215., 216., 217., 217.5, 218., 218.5,
      222.5, 223., 223.5, 224., 225., 226., 227., 227.5, 228., 228.5,
      232.5, 233., 233.5, 234., 235., 236., 237., 237.5, 238., 238.5,
      237.5, 238., 238.5, 239., 240., 241., 242., 242.5, 243., 243.5,
      242.5, 243., 243.5, 244., 245., 246., 247., 247.5, 248., 248.5,
      247.5, 248., 248.5, 249., 250., 251., 252., 252.5, 253., 253.5};
  const std::array<int, 4> in_shape = {{3, 9, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  36.,  37.,  44.,  45.,  46.,  47.,  54.,  55.,  56.,  57.,
      124., 125., 126., 127., 134., 135., 136., 137., 144., 145., 146., 147.,
      214., 215., 216., 217., 224., 225., 226., 227., 234., 235., 236., 237.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  35.,  36.,  36.,  37.,  37.,  38.,  39.,  40.,  41.,  42.,
      43.,  44.,  44.,  45.,  45.,  46.,  46.,  47.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  54.,  55.,
      55.,  56.,  56.,  57.,  54.,  55.,  55.,  56.,  56.,  57.,  57.,  58.,
      59.,  60.,  61.,  62.,  63.,  64.,  64.,  65.,  65.,  66.,  66.,  67.,
      64.,  65.,  65.,  66.,  66.,  67.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  94.,  95.,
      95.,  96.,  96.,  97.,  104., 105., 105., 106., 106., 107., 107., 108.,
      109., 110., 111., 112., 113., 114., 114., 115., 115., 116., 116., 117.,
      114., 115., 115., 116., 116., 117., 117., 118., 119., 120., 121., 122.,
      123., 124., 124., 125., 125., 126., 126., 127., 124., 125., 125., 126.,
      126., 127., 127., 128., 129., 130., 131., 132., 133., 134., 134., 135.,
      135., 136., 136., 137., 134., 135., 135., 136., 136., 137., 137., 138.,
      139., 140., 141., 142., 143., 144., 144., 145., 145., 146., 146., 147.,
      214., 215., 215., 216., 216., 217., 217., 218., 219., 220., 221., 222.,
      223., 224., 224., 225., 225., 226., 226., 227., 224., 225., 225., 226.,
      226., 227., 227., 228., 229., 230., 231., 232., 233., 234., 234., 235.,
      235., 236., 236., 237., 234., 235., 235., 236., 236., 237., 237., 238.,
      239., 240., 241., 242., 243., 244., 244., 245., 245., 246., 246., 247.,
      244., 245., 245., 246., 246., 247., 247., 248., 249., 250., 251., 252.,
      253., 254., 254., 255., 255., 256., 256., 257., 264., 265., 265., 266.,
      266., 267., 267., 268., 269., 270., 271., 272., 273., 274., 274., 275.,
      275., 276., 276., 277., 284., 285., 285., 286., 286., 287., 287., 288.,
      289., 290., 291., 292., 293., 294., 294., 295., 295., 296., 296., 297.,
      294., 295., 295., 296., 296., 297., 297., 298., 299., 300., 301., 302.,
      303., 304., 304., 305., 305., 306., 306., 307., 304., 305., 305., 306.,
      306., 307., 307., 308., 309., 310., 311., 312., 313., 314., 314., 315.,
      315., 316., 316., 317., 314., 315., 315., 316., 316., 317., 317., 318.,
      319., 320., 321., 322., 323., 324., 324., 325., 325., 326., 326., 327.,
      394., 395., 395., 396., 396., 397., 397., 398., 399., 400., 401., 402.,
      403., 404., 404., 405., 405., 406., 406., 407., 404., 405., 405., 406.,
      406., 407., 407., 408., 409., 410., 411., 412., 413., 414., 414., 415.,
      415., 416., 416., 417., 414., 415., 415., 416., 416., 417., 417., 418.,
      419., 420., 421., 422., 423., 424., 424., 425., 425., 426., 426., 427.,
      424., 425., 425., 426., 426., 427., 427., 428., 429., 430., 431., 432.,
      433., 434., 434., 435., 435., 436., 436., 437., 444., 445., 445., 446.,
      446., 447., 447., 448., 449., 450., 451., 452., 453., 454., 454., 455.,
      455., 456., 456., 457., 464., 465., 465., 466., 466., 467., 467., 468.,
      469., 470., 471., 472., 473., 474., 474., 475., 475., 476., 476., 477.,
      474., 475., 475., 476., 476., 477., 477., 478., 479., 480., 481., 482.,
      483., 484., 484., 485., 485., 486., 486., 487., 484., 485., 485., 486.,
      486., 487., 487., 488., 489., 490., 491., 492., 493., 494., 494., 495.,
      495., 496., 496., 497., 494., 495., 495., 496., 496., 497., 497., 498.,
      499., 500., 501., 502., 503., 504., 504., 505., 505., 506., 506., 507.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  107., 108., 109., 110., 111., 112., 113., 114.,
      247., 248., 249., 250., 251., 252., 253., 254., 267., 268., 269., 270.,
      271., 272., 273., 274., 287., 288., 289., 290., 291., 292., 293., 294.,
      427., 428., 429., 430., 431., 432., 433., 434., 447., 448., 449., 450.,
      451., 452., 453., 454., 467., 468., 469., 470., 471., 472., 473., 474.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,   68.,   69.,   70.,   69.,   70.,   71.,   72.,   71.,   72.,
      73.,   74.,   73.,   74.,   75.,   76.,   77.,   78.,   79.,   80.,
      81.,   82.,   83.,   84.,   85.,   86.,   87.,   88.,   87.,   88.,
      89.,   90.,   89.,   90.,   91.,   92.,   91.,   92.,   93.,   94.,
      87.,   88.,   89.,   90.,   89.,   90.,   91.,   92.,   91.,   92.,
      93.,   94.,   93.,   94.,   95.,   96.,   97.,   98.,   99.,   100.,
      101.,  102.,  103.,  104.,  105.,  106.,  107.,  108.,  107.,  108.,
      109.,  110.,  109.,  110.,  111.,  112.,  111.,  112.,  113.,  114.,
      107.,  108.,  109.,  110.,  109.,  110.,  111.,  112.,  111.,  112.,
      113.,  114.,  113.,  114.,  115.,  116.,  117.,  118.,  119.,  120.,
      121.,  122.,  123.,  124.,  125.,  126.,  127.,  128.,  127.,  128.,
      129.,  130.,  129.,  130.,  131.,  132.,  131.,  132.,  133.,  134.,
      127.,  128.,  129.,  130.,  129.,  130.,  131.,  132.,  131.,  132.,
      133.,  134.,  133.,  134.,  135.,  136.,  137.,  138.,  139.,  140.,
      141.,  142.,  143.,  144.,  145.,  146.,  147.,  148.,  147.,  148.,
      149.,  150.,  149.,  150.,  151.,  152.,  151.,  152.,  153.,  154.,
      167.,  168.,  169.,  170.,  169.,  170.,  171.,  172.,  171.,  172.,
      173.,  174.,  173.,  174.,  175.,  176.,  177.,  178.,  179.,  180.,
      181.,  182.,  183.,  184.,  185.,  186.,  187.,  188.,  187.,  188.,
      189.,  190.,  189.,  190.,  191.,  192.,  191.,  192.,  193.,  194.,
      207.,  208.,  209.,  210.,  209.,  210.,  211.,  212.,  211.,  212.,
      213.,  214.,  213.,  214.,  215.,  216.,  217.,  218.,  219.,  220.,
      221.,  222.,  223.,  224.,  225.,  226.,  227.,  228.,  227.,  228.,
      229.,  230.,  229.,  230.,  231.,  232.,  231.,  232.,  233.,  234.,
      227.,  228.,  229.,  230.,  229.,  230.,  231.,  232.,  231.,  232.,
      233.,  234.,  233.,  234.,  235.,  236.,  237.,  238.,  239.,  240.,
      241.,  242.,  243.,  244.,  245.,  246.,  247.,  248.,  247.,  248.,
      249.,  250.,  249.,  250.,  251.,  252.,  251.,  252.,  253.,  254.,
      247.,  248.,  249.,  250.,  249.,  250.,  251.,  252.,  251.,  252.,
      253.,  254.,  253.,  254.,  255.,  256.,  257.,  258.,  259.,  260.,
      261.,  262.,  263.,  264.,  265.,  266.,  267.,  268.,  267.,  268.,
      269.,  270.,  269.,  270.,  271.,  272.,  271.,  272.,  273.,  274.,
      267.,  268.,  269.,  270.,  269.,  270.,  271.,  272.,  271.,  272.,
      273.,  274.,  273.,  274.,  275.,  276.,  277.,  278.,  279.,  280.,
      281.,  282.,  283.,  284.,  285.,  286.,  287.,  288.,  287.,  288.,
      289.,  290.,  289.,  290.,  291.,  292.,  291.,  292.,  293.,  294.,
      427.,  428.,  429.,  430.,  429.,  430.,  431.,  432.,  431.,  432.,
      433.,  434.,  433.,  434.,  435.,  436.,  437.,  438.,  439.,  440.,
      441.,  442.,  443.,  444.,  445.,  446.,  447.,  448.,  447.,  448.,
      449.,  450.,  449.,  450.,  451.,  452.,  451.,  452.,  453.,  454.,
      447.,  448.,  449.,  450.,  449.,  450.,  451.,  452.,  451.,  452.,
      453.,  454.,  453.,  454.,  455.,  456.,  457.,  458.,  459.,  460.,
      461.,  462.,  463.,  464.,  465.,  466.,  467.,  468.,  467.,  468.,
      469.,  470.,  469.,  470.,  471.,  472.,  471.,  472.,  473.,  474.,
      467.,  468.,  469.,  470.,  469.,  470.,  471.,  472.,  471.,  472.,
      473.,  474.,  473.,  474.,  475.,  476.,  477.,  478.,  479.,  480.,
      481.,  482.,  483.,  484.,  485.,  486.,  487.,  488.,  487.,  488.,
      489.,  490.,  489.,  490.,  491.,  492.,  491.,  492.,  493.,  494.,
      487.,  488.,  489.,  490.,  489.,  490.,  491.,  492.,  491.,  492.,
      493.,  494.,  493.,  494.,  495.,  496.,  497.,  498.,  499.,  500.,
      501.,  502.,  503.,  504.,  505.,  506.,  507.,  508.,  507.,  508.,
      509.,  510.,  509.,  510.,  511.,  512.,  511.,  512.,  513.,  514.,
      527.,  528.,  529.,  530.,  529.,  530.,  531.,  532.,  531.,  532.,
      533.,  534.,  533.,  534.,  535.,  536.,  537.,  538.,  539.,  540.,
      541.,  542.,  543.,  544.,  545.,  546.,  547.,  548.,  547.,  548.,
      549.,  550.,  549.,  550.,  551.,  552.,  551.,  552.,  553.,  554.,
      567.,  568.,  569.,  570.,  569.,  570.,  571.,  572.,  571.,  572.,
      573.,  574.,  573.,  574.,  575.,  576.,  577.,  578.,  579.,  580.,
      581.,  582.,  583.,  584.,  585.,  586.,  587.,  588.,  587.,  588.,
      589.,  590.,  589.,  590.,  591.,  592.,  591.,  592.,  593.,  594.,
      587.,  588.,  589.,  590.,  589.,  590.,  591.,  592.,  591.,  592.,
      593.,  594.,  593.,  594.,  595.,  596.,  597.,  598.,  599.,  600.,
      601.,  602.,  603.,  604.,  605.,  606.,  607.,  608.,  607.,  608.,
      609.,  610.,  609.,  610.,  611.,  612.,  611.,  612.,  613.,  614.,
      607.,  608.,  609.,  610.,  609.,  610.,  611.,  612.,  611.,  612.,
      613.,  614.,  613.,  614.,  615.,  616.,  617.,  618.,  619.,  620.,
      621.,  622.,  623.,  624.,  625.,  626.,  627.,  628.,  627.,  628.,
      629.,  630.,  629.,  630.,  631.,  632.,  631.,  632.,  633.,  634.,
      627.,  628.,  629.,  630.,  629.,  630.,  631.,  632.,  631.,  632.,
      633.,  634.,  633.,  634.,  635.,  636.,  637.,  638.,  639.,  640.,
      641.,  642.,  643.,  644.,  645.,  646.,  647.,  648.,  647.,  648.,
      649.,  650.,  649.,  650.,  651.,  652.,  651.,  652.,  653.,  654.,
      787.,  788.,  789.,  790.,  789.,  790.,  791.,  792.,  791.,  792.,
      793.,  794.,  793.,  794.,  795.,  796.,  797.,  798.,  799.,  800.,
      801.,  802.,  803.,  804.,  805.,  806.,  807.,  808.,  807.,  808.,
      809.,  810.,  809.,  810.,  811.,  812.,  811.,  812.,  813.,  814.,
      807.,  808.,  809.,  810.,  809.,  810.,  811.,  812.,  811.,  812.,
      813.,  814.,  813.,  814.,  815.,  816.,  817.,  818.,  819.,  820.,
      821.,  822.,  823.,  824.,  825.,  826.,  827.,  828.,  827.,  828.,
      829.,  830.,  829.,  830.,  831.,  832.,  831.,  832.,  833.,  834.,
      827.,  828.,  829.,  830.,  829.,  830.,  831.,  832.,  831.,  832.,
      833.,  834.,  833.,  834.,  835.,  836.,  837.,  838.,  839.,  840.,
      841.,  842.,  843.,  844.,  845.,  846.,  847.,  848.,  847.,  848.,
      849.,  850.,  849.,  850.,  851.,  852.,  851.,  852.,  853.,  854.,
      847.,  848.,  849.,  850.,  849.,  850.,  851.,  852.,  851.,  852.,
      853.,  854.,  853.,  854.,  855.,  856.,  857.,  858.,  859.,  860.,
      861.,  862.,  863.,  864.,  865.,  866.,  867.,  868.,  867.,  868.,
      869.,  870.,  869.,  870.,  871.,  872.,  871.,  872.,  873.,  874.,
      887.,  888.,  889.,  890.,  889.,  890.,  891.,  892.,  891.,  892.,
      893.,  894.,  893.,  894.,  895.,  896.,  897.,  898.,  899.,  900.,
      901.,  902.,  903.,  904.,  905.,  906.,  907.,  908.,  907.,  908.,
      909.,  910.,  909.,  910.,  911.,  912.,  911.,  912.,  913.,  914.,
      927.,  928.,  929.,  930.,  929.,  930.,  931.,  932.,  931.,  932.,
      933.,  934.,  933.,  934.,  935.,  936.,  937.,  938.,  939.,  940.,
      941.,  942.,  943.,  944.,  945.,  946.,  947.,  948.,  947.,  948.,
      949.,  950.,  949.,  950.,  951.,  952.,  951.,  952.,  953.,  954.,
      947.,  948.,  949.,  950.,  949.,  950.,  951.,  952.,  951.,  952.,
      953.,  954.,  953.,  954.,  955.,  956.,  957.,  958.,  959.,  960.,
      961.,  962.,  963.,  964.,  965.,  966.,  967.,  968.,  967.,  968.,
      969.,  970.,  969.,  970.,  971.,  972.,  971.,  972.,  973.,  974.,
      967.,  968.,  969.,  970.,  969.,  970.,  971.,  972.,  971.,  972.,
      973.,  974.,  973.,  974.,  975.,  976.,  977.,  978.,  979.,  980.,
      981.,  982.,  983.,  984.,  985.,  986.,  987.,  988.,  987.,  988.,
      989.,  990.,  989.,  990.,  991.,  992.,  991.,  992.,  993.,  994.,
      987.,  988.,  989.,  990.,  989.,  990.,  991.,  992.,  991.,  992.,
      993.,  994.,  993.,  994.,  995.,  996.,  997.,  998.,  999.,  1000.,
      1001., 1002., 1003., 1004., 1005., 1006., 1007., 1008., 1007., 1008.,
      1009., 1010., 1009., 1010., 1011., 1012., 1011., 1012., 1013., 1014.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 533., 534., 535., 536., 537., 538., 539., 540.,
      541., 542., 543., 544., 545., 546., 547., 548., 573., 574., 575., 576.,
      577., 578., 579., 580., 581., 582., 583., 584., 585., 586., 587., 588.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      865., 866., 867., 868., 893., 894., 895., 896., 897., 898., 899., 900.,
      901., 902., 903., 904., 905., 906., 907., 908., 933., 934., 935., 936.,
      937., 938., 939., 940., 941., 942., 943., 944., 945., 946., 947., 948.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14.5,  15.,   15.5,  16.,   17.,   17.5,  18.,   18.5,  18.5,  19.,
      19.5,  20.,   21.,   21.5,  22.,   22.5,  22.5,  23.,   23.5,  24.,
      25.,   25.5,  26.,   26.5,  26.5,  27.,   27.5,  28.,   29.,   29.5,
      30.,   30.5,  34.5,  35.,   35.5,  36.,   37.,   37.5,  38.,   38.5,
      42.5,  43.,   43.5,  44.,   45.,   45.5,  46.,   46.5,  50.5,  51.,
      51.5,  52.,   53.,   53.5,  54.,   54.5,  54.5,  55.,   55.5,  56.,
      57.,   57.5,  58.,   58.5,  58.5,  59.,   59.5,  60.,   61.,   61.5,
      62.,   62.5,  62.5,  63.,   63.5,  64.,   65.,   65.5,  66.,   66.5,
      94.5,  95.,   95.5,  96.,   97.,   97.5,  98.,   98.5,  98.5,  99.,
      99.5,  100.,  101.,  101.5, 102.,  102.5, 102.5, 103.,  103.5, 104.,
      105.,  105.5, 106.,  106.5, 106.5, 107.,  107.5, 108.,  109.,  109.5,
      110.,  110.5, 114.5, 115.,  115.5, 116.,  117.,  117.5, 118.,  118.5,
      122.5, 123.,  123.5, 124.,  125.,  125.5, 126.,  126.5, 130.5, 131.,
      131.5, 132.,  133.,  133.5, 134.,  134.5, 134.5, 135.,  135.5, 136.,
      137.,  137.5, 138.,  138.5, 138.5, 139.,  139.5, 140.,  141.,  141.5,
      142.,  142.5, 142.5, 143.,  143.5, 144.,  145.,  145.5, 146.,  146.5,
      174.5, 175.,  175.5, 176.,  177.,  177.5, 178.,  178.5, 178.5, 179.,
      179.5, 180.,  181.,  181.5, 182.,  182.5, 182.5, 183.,  183.5, 184.,
      185.,  185.5, 186.,  186.5, 186.5, 187.,  187.5, 188.,  189.,  189.5,
      190.,  190.5, 194.5, 195.,  195.5, 196.,  197.,  197.5, 198.,  198.5,
      202.5, 203.,  203.5, 204.,  205.,  205.5, 206.,  206.5, 210.5, 211.,
      211.5, 212.,  213.,  213.5, 214.,  214.5, 214.5, 215.,  215.5, 216.,
      217.,  217.5, 218.,  218.5, 218.5, 219.,  219.5, 220.,  221.,  221.5,
      222.,  222.5, 222.5, 223.,  223.5, 224.,  225.,  225.5, 226.,  226.5};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  36.,  37.,  44.,  45.,  52.,  53.,  108., 109., 116., 117.,
      124., 125., 132., 133., 188., 189., 196., 197., 204., 205., 212., 213.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  29.,  30.,  30.,  31.,  31.,  32.,  33.,  34.,  34.,  35.,
      35.,  36.,  36.,  37.,  36.,  37.,  37.,  38.,  38.,  39.,  39.,  40.,
      41.,  42.,  42.,  43.,  43.,  44.,  44.,  45.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,
      52.,  53.,  53.,  54.,  54.,  55.,  55.,  56.,  57.,  58.,  58.,  59.,
      59.,  60.,  60.,  61.,  68.,  69.,  69.,  70.,  70.,  71.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  90.,  91.,  91.,  92.,  92.,  93.,
      100., 101., 101., 102., 102., 103., 103., 104., 105., 106., 106., 107.,
      107., 108., 108., 109., 108., 109., 109., 110., 110., 111., 111., 112.,
      113., 114., 114., 115., 115., 116., 116., 117., 116., 117., 117., 118.,
      118., 119., 119., 120., 121., 122., 122., 123., 123., 124., 124., 125.,
      124., 125., 125., 126., 126., 127., 127., 128., 129., 130., 130., 131.,
      131., 132., 132., 133., 188., 189., 189., 190., 190., 191., 191., 192.,
      193., 194., 194., 195., 195., 196., 196., 197., 196., 197., 197., 198.,
      198., 199., 199., 200., 201., 202., 202., 203., 203., 204., 204., 205.,
      204., 205., 205., 206., 206., 207., 207., 208., 209., 210., 210., 211.,
      211., 212., 212., 213., 212., 213., 213., 214., 214., 215., 215., 216.,
      217., 218., 218., 219., 219., 220., 220., 221., 228., 229., 229., 230.,
      230., 231., 231., 232., 233., 234., 234., 235., 235., 236., 236., 237.,
      244., 245., 245., 246., 246., 247., 247., 248., 249., 250., 250., 251.,
      251., 252., 252., 253., 260., 261., 261., 262., 262., 263., 263., 264.,
      265., 266., 266., 267., 267., 268., 268., 269., 268., 269., 269., 270.,
      270., 271., 271., 272., 273., 274., 274., 275., 275., 276., 276., 277.,
      276., 277., 277., 278., 278., 279., 279., 280., 281., 282., 282., 283.,
      283., 284., 284., 285., 284., 285., 285., 286., 286., 287., 287., 288.,
      289., 290., 290., 291., 291., 292., 292., 293., 348., 349., 349., 350.,
      350., 351., 351., 352., 353., 354., 354., 355., 355., 356., 356., 357.,
      356., 357., 357., 358., 358., 359., 359., 360., 361., 362., 362., 363.,
      363., 364., 364., 365., 364., 365., 365., 366., 366., 367., 367., 368.,
      369., 370., 370., 371., 371., 372., 372., 373., 372., 373., 373., 374.,
      374., 375., 375., 376., 377., 378., 378., 379., 379., 380., 380., 381.,
      388., 389., 389., 390., 390., 391., 391., 392., 393., 394., 394., 395.,
      395., 396., 396., 397., 404., 405., 405., 406., 406., 407., 407., 408.,
      409., 410., 410., 411., 411., 412., 412., 413., 420., 421., 421., 422.,
      422., 423., 423., 424., 425., 426., 426., 427., 427., 428., 428., 429.,
      428., 429., 429., 430., 430., 431., 431., 432., 433., 434., 434., 435.,
      435., 436., 436., 437., 436., 437., 437., 438., 438., 439., 439., 440.,
      441., 442., 442., 443., 443., 444., 444., 445., 444., 445., 445., 446.,
      446., 447., 447., 448., 449., 450., 450., 451., 451., 452., 452., 453.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  71.,  72.,  73.,  74.,  87.,  88.,  89.,  90.,
      103., 104., 105., 106., 215., 216., 217., 218., 231., 232., 233., 234.,
      247., 248., 249., 250., 263., 264., 265., 266., 375., 376., 377., 378.,
      391., 392., 393., 394., 407., 408., 409., 410., 423., 424., 425., 426.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  67.,  68.,  69.,  70.,
      69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  85.,  86.,  85.,  86.,  87.,  88.,
      87.,  88.,  89.,  90.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      99.,  100., 101., 102., 101., 102., 103., 104., 103., 104., 105., 106.,
      103., 104., 105., 106., 105., 106., 107., 108., 107., 108., 109., 110.,
      109., 110., 111., 112., 113., 114., 115., 116., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 135., 136., 137., 138.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      151., 152., 153., 154., 167., 168., 169., 170., 169., 170., 171., 172.,
      171., 172., 173., 174., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 181., 182., 181., 182., 183., 184., 183., 184., 185., 186.,
      199., 200., 201., 202., 201., 202., 203., 204., 203., 204., 205., 206.,
      205., 206., 207., 208., 209., 210., 211., 212., 211., 212., 213., 214.,
      213., 214., 215., 216., 215., 216., 217., 218., 215., 216., 217., 218.,
      217., 218., 219., 220., 219., 220., 221., 222., 221., 222., 223., 224.,
      225., 226., 227., 228., 227., 228., 229., 230., 229., 230., 231., 232.,
      231., 232., 233., 234., 231., 232., 233., 234., 233., 234., 235., 236.,
      235., 236., 237., 238., 237., 238., 239., 240., 241., 242., 243., 244.,
      243., 244., 245., 246., 245., 246., 247., 248., 247., 248., 249., 250.,
      247., 248., 249., 250., 249., 250., 251., 252., 251., 252., 253., 254.,
      253., 254., 255., 256., 257., 258., 259., 260., 259., 260., 261., 262.,
      261., 262., 263., 264., 263., 264., 265., 266., 375., 376., 377., 378.,
      377., 378., 379., 380., 379., 380., 381., 382., 381., 382., 383., 384.,
      385., 386., 387., 388., 387., 388., 389., 390., 389., 390., 391., 392.,
      391., 392., 393., 394., 391., 392., 393., 394., 393., 394., 395., 396.,
      395., 396., 397., 398., 397., 398., 399., 400., 401., 402., 403., 404.,
      403., 404., 405., 406., 405., 406., 407., 408., 407., 408., 409., 410.,
      407., 408., 409., 410., 409., 410., 411., 412., 411., 412., 413., 414.,
      413., 414., 415., 416., 417., 418., 419., 420., 419., 420., 421., 422.,
      421., 422., 423., 424., 423., 424., 425., 426., 423., 424., 425., 426.,
      425., 426., 427., 428., 427., 428., 429., 430., 429., 430., 431., 432.,
      433., 434., 435., 436., 435., 436., 437., 438., 437., 438., 439., 440.,
      439., 440., 441., 442., 455., 456., 457., 458., 457., 458., 459., 460.,
      459., 460., 461., 462., 461., 462., 463., 464., 465., 466., 467., 468.,
      467., 468., 469., 470., 469., 470., 471., 472., 471., 472., 473., 474.,
      487., 488., 489., 490., 489., 490., 491., 492., 491., 492., 493., 494.,
      493., 494., 495., 496., 497., 498., 499., 500., 499., 500., 501., 502.,
      501., 502., 503., 504., 503., 504., 505., 506., 519., 520., 521., 522.,
      521., 522., 523., 524., 523., 524., 525., 526., 525., 526., 527., 528.,
      529., 530., 531., 532., 531., 532., 533., 534., 533., 534., 535., 536.,
      535., 536., 537., 538., 535., 536., 537., 538., 537., 538., 539., 540.,
      539., 540., 541., 542., 541., 542., 543., 544., 545., 546., 547., 548.,
      547., 548., 549., 550., 549., 550., 551., 552., 551., 552., 553., 554.,
      551., 552., 553., 554., 553., 554., 555., 556., 555., 556., 557., 558.,
      557., 558., 559., 560., 561., 562., 563., 564., 563., 564., 565., 566.,
      565., 566., 567., 568., 567., 568., 569., 570., 567., 568., 569., 570.,
      569., 570., 571., 572., 571., 572., 573., 574., 573., 574., 575., 576.,
      577., 578., 579., 580., 579., 580., 581., 582., 581., 582., 583., 584.,
      583., 584., 585., 586., 695., 696., 697., 698., 697., 698., 699., 700.,
      699., 700., 701., 702., 701., 702., 703., 704., 705., 706., 707., 708.,
      707., 708., 709., 710., 709., 710., 711., 712., 711., 712., 713., 714.,
      711., 712., 713., 714., 713., 714., 715., 716., 715., 716., 717., 718.,
      717., 718., 719., 720., 721., 722., 723., 724., 723., 724., 725., 726.,
      725., 726., 727., 728., 727., 728., 729., 730., 727., 728., 729., 730.,
      729., 730., 731., 732., 731., 732., 733., 734., 733., 734., 735., 736.,
      737., 738., 739., 740., 739., 740., 741., 742., 741., 742., 743., 744.,
      743., 744., 745., 746., 743., 744., 745., 746., 745., 746., 747., 748.,
      747., 748., 749., 750., 749., 750., 751., 752., 753., 754., 755., 756.,
      755., 756., 757., 758., 757., 758., 759., 760., 759., 760., 761., 762.,
      775., 776., 777., 778., 777., 778., 779., 780., 779., 780., 781., 782.,
      781., 782., 783., 784., 785., 786., 787., 788., 787., 788., 789., 790.,
      789., 790., 791., 792., 791., 792., 793., 794., 807., 808., 809., 810.,
      809., 810., 811., 812., 811., 812., 813., 814., 813., 814., 815., 816.,
      817., 818., 819., 820., 819., 820., 821., 822., 821., 822., 823., 824.,
      823., 824., 825., 826., 839., 840., 841., 842., 841., 842., 843., 844.,
      843., 844., 845., 846., 845., 846., 847., 848., 849., 850., 851., 852.,
      851., 852., 853., 854., 853., 854., 855., 856., 855., 856., 857., 858.,
      855., 856., 857., 858., 857., 858., 859., 860., 859., 860., 861., 862.,
      861., 862., 863., 864., 865., 866., 867., 868., 867., 868., 869., 870.,
      869., 870., 871., 872., 871., 872., 873., 874., 871., 872., 873., 874.,
      873., 874., 875., 876., 875., 876., 877., 878., 877., 878., 879., 880.,
      881., 882., 883., 884., 883., 884., 885., 886., 885., 886., 887., 888.,
      887., 888., 889., 890., 887., 888., 889., 890., 889., 890., 891., 892.,
      891., 892., 893., 894., 893., 894., 895., 896., 897., 898., 899., 900.,
      899., 900., 901., 902., 901., 902., 903., 904., 903., 904., 905., 906.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 141., 142., 143., 144.,
      145., 146., 147., 148., 173., 174., 175., 176., 177., 178., 179., 180.,
      205., 206., 207., 208., 209., 210., 211., 212., 429., 430., 431., 432.,
      433., 434., 435., 436., 461., 462., 463., 464., 465., 466., 467., 468.,
      493., 494., 495., 496., 497., 498., 499., 500., 525., 526., 527., 528.,
      529., 530., 531., 532., 749., 750., 751., 752., 753., 754., 755., 756.,
      781., 782., 783., 784., 785., 786., 787., 788., 813., 814., 815., 816.,
      817., 818., 819., 820., 845., 846., 847., 848., 849., 850., 851., 852.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16.,   16.5,  17.,   17.5,  18.5,  19.5,  20.,   20.5,  21.,   20.5,
      21.,   21.5,  22.,   23.,   24.,   24.5,  25.,   25.5,  25.,   25.5,
      26.,   26.5,  27.5,  28.5,  29.,   29.5,  30.,   29.5,  30.,   30.5,
      31.,   32.,   33.,   33.5,  34.,   34.5,  38.5,  39.,   39.5,  40.,
      41.,   42.,   42.5,  43.,   43.5,  47.5,  48.,   48.5,  49.,   50.,
      51.,   51.5,  52.,   52.5,  56.5,  57.,   57.5,  58.,   59.,   60.,
      60.5,  61.,   61.5,  61.,   61.5,  62.,   62.5,  63.5,  64.5,  65.,
      65.5,  66.,   65.5,  66.,   66.5,  67.,   68.,   69.,   69.5,  70.,
      70.5,  70.,   70.5,  71.,   71.5,  72.5,  73.5,  74.,   74.5,  75.,
      106.,  106.5, 107.,  107.5, 108.5, 109.5, 110.,  110.5, 111.,  110.5,
      111.,  111.5, 112.,  113.,  114.,  114.5, 115.,  115.5, 115.,  115.5,
      116.,  116.5, 117.5, 118.5, 119.,  119.5, 120.,  119.5, 120.,  120.5,
      121.,  122.,  123.,  123.5, 124.,  124.5, 128.5, 129.,  129.5, 130.,
      131.,  132.,  132.5, 133.,  133.5, 137.5, 138.,  138.5, 139.,  140.,
      141.,  141.5, 142.,  142.5, 146.5, 147.,  147.5, 148.,  149.,  150.,
      150.5, 151.,  151.5, 151.,  151.5, 152.,  152.5, 153.5, 154.5, 155.,
      155.5, 156.,  155.5, 156.,  156.5, 157.,  158.,  159.,  159.5, 160.,
      160.5, 160.,  160.5, 161.,  161.5, 162.5, 163.5, 164.,  164.5, 165.,
      196.,  196.5, 197.,  197.5, 198.5, 199.5, 200.,  200.5, 201.,  200.5,
      201.,  201.5, 202.,  203.,  204.,  204.5, 205.,  205.5, 205.,  205.5,
      206.,  206.5, 207.5, 208.5, 209.,  209.5, 210.,  209.5, 210.,  210.5,
      211.,  212.,  213.,  213.5, 214.,  214.5, 218.5, 219.,  219.5, 220.,
      221.,  222.,  222.5, 223.,  223.5, 227.5, 228.,  228.5, 229.,  230.,
      231.,  231.5, 232.,  232.5, 236.5, 237.,  237.5, 238.,  239.,  240.,
      240.5, 241.,  241.5, 241.,  241.5, 242.,  242.5, 243.5, 244.5, 245.,
      245.5, 246.,  245.5, 246.,  246.5, 247.,  248.,  249.,  249.5, 250.,
      250.5, 250.,  250.5, 251.,  251.5, 252.5, 253.5, 254.,  254.5, 255.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  33.,  40.,  41.,  42.,  49.,  50.,  51.,  58.,  59.,  60.,
      121., 122., 123., 130., 131., 132., 139., 140., 141., 148., 149., 150.,
      211., 212., 213., 220., 221., 222., 229., 230., 231., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  32.,  33.,  33.,  34.,  34.,  35.,  36.,  37.,  38.,  39.,
      39.,  40.,  40.,  41.,  41.,  42.,  40.,  41.,  41.,  42.,  42.,  43.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  49.,  49.,  50.,  50.,  51.,
      49.,  50.,  50.,  51.,  51.,  52.,  52.,  53.,  54.,  55.,  56.,  57.,
      57.,  58.,  58.,  59.,  59.,  60.,  58.,  59.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  68.,  69.,
      76.,  77.,  77.,  78.,  78.,  79.,  79.,  80.,  81.,  82.,  83.,  84.,
      84.,  85.,  85.,  86.,  86.,  87.,  94.,  95.,  95.,  96.,  96.,  97.,
      97.,  98.,  99.,  100., 101., 102., 102., 103., 103., 104., 104., 105.,
      112., 113., 113., 114., 114., 115., 115., 116., 117., 118., 119., 120.,
      120., 121., 121., 122., 122., 123., 121., 122., 122., 123., 123., 124.,
      124., 125., 126., 127., 128., 129., 129., 130., 130., 131., 131., 132.,
      130., 131., 131., 132., 132., 133., 133., 134., 135., 136., 137., 138.,
      138., 139., 139., 140., 140., 141., 139., 140., 140., 141., 141., 142.,
      142., 143., 144., 145., 146., 147., 147., 148., 148., 149., 149., 150.,
      211., 212., 212., 213., 213., 214., 214., 215., 216., 217., 218., 219.,
      219., 220., 220., 221., 221., 222., 220., 221., 221., 222., 222., 223.,
      223., 224., 225., 226., 227., 228., 228., 229., 229., 230., 230., 231.,
      229., 230., 230., 231., 231., 232., 232., 233., 234., 235., 236., 237.,
      237., 238., 238., 239., 239., 240., 238., 239., 239., 240., 240., 241.,
      241., 242., 243., 244., 245., 246., 246., 247., 247., 248., 248., 249.,
      256., 257., 257., 258., 258., 259., 259., 260., 261., 262., 263., 264.,
      264., 265., 265., 266., 266., 267., 274., 275., 275., 276., 276., 277.,
      277., 278., 279., 280., 281., 282., 282., 283., 283., 284., 284., 285.,
      292., 293., 293., 294., 294., 295., 295., 296., 297., 298., 299., 300.,
      300., 301., 301., 302., 302., 303., 301., 302., 302., 303., 303., 304.,
      304., 305., 306., 307., 308., 309., 309., 310., 310., 311., 311., 312.,
      310., 311., 311., 312., 312., 313., 313., 314., 315., 316., 317., 318.,
      318., 319., 319., 320., 320., 321., 319., 320., 320., 321., 321., 322.,
      322., 323., 324., 325., 326., 327., 327., 328., 328., 329., 329., 330.,
      391., 392., 392., 393., 393., 394., 394., 395., 396., 397., 398., 399.,
      399., 400., 400., 401., 401., 402., 400., 401., 401., 402., 402., 403.,
      403., 404., 405., 406., 407., 408., 408., 409., 409., 410., 410., 411.,
      409., 410., 410., 411., 411., 412., 412., 413., 414., 415., 416., 417.,
      417., 418., 418., 419., 419., 420., 418., 419., 419., 420., 420., 421.,
      421., 422., 423., 424., 425., 426., 426., 427., 427., 428., 428., 429.,
      436., 437., 437., 438., 438., 439., 439., 440., 441., 442., 443., 444.,
      444., 445., 445., 446., 446., 447., 454., 455., 455., 456., 456., 457.,
      457., 458., 459., 460., 461., 462., 462., 463., 463., 464., 464., 465.,
      472., 473., 473., 474., 474., 475., 475., 476., 477., 478., 479., 480.,
      480., 481., 481., 482., 482., 483., 481., 482., 482., 483., 483., 484.,
      484., 485., 486., 487., 488., 489., 489., 490., 490., 491., 491., 492.,
      490., 491., 491., 492., 492., 493., 493., 494., 495., 496., 497., 498.,
      498., 499., 499., 500., 500., 501., 499., 500., 500., 501., 501., 502.,
      502., 503., 504., 505., 506., 507., 507., 508., 508., 509., 509., 510.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  79.,  80.,  81.,  82.,  83.,  84.,
      97.,  98.,  99.,  100., 101., 102., 115., 116., 117., 118., 119., 120.,
      241., 242., 243., 244., 245., 246., 259., 260., 261., 262., 263., 264.,
      277., 278., 279., 280., 281., 282., 295., 296., 297., 298., 299., 300.,
      421., 422., 423., 424., 425., 426., 439., 440., 441., 442., 443., 444.,
      457., 458., 459., 460., 461., 462., 475., 476., 477., 478., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,   62.,   63.,   64.,   63.,   64.,   65.,   66.,   65.,   66.,
      67.,   68.,   67.,   68.,   69.,   70.,   71.,   72.,   73.,   74.,
      75.,   76.,   77.,   78.,   77.,   78.,   79.,   80.,   79.,   80.,
      81.,   82.,   81.,   82.,   83.,   84.,   79.,   80.,   81.,   82.,
      81.,   82.,   83.,   84.,   83.,   84.,   85.,   86.,   85.,   86.,
      87.,   88.,   89.,   90.,   91.,   92.,   93.,   94.,   95.,   96.,
      95.,   96.,   97.,   98.,   97.,   98.,   99.,   100.,  99.,   100.,
      101.,  102.,  97.,   98.,   99.,   100.,  99.,   100.,  101.,  102.,
      101.,  102.,  103.,  104.,  103.,  104.,  105.,  106.,  107.,  108.,
      109.,  110.,  111.,  112.,  113.,  114.,  113.,  114.,  115.,  116.,
      115.,  116.,  117.,  118.,  117.,  118.,  119.,  120.,  115.,  116.,
      117.,  118.,  117.,  118.,  119.,  120.,  119.,  120.,  121.,  122.,
      121.,  122.,  123.,  124.,  125.,  126.,  127.,  128.,  129.,  130.,
      131.,  132.,  131.,  132.,  133.,  134.,  133.,  134.,  135.,  136.,
      135.,  136.,  137.,  138.,  151.,  152.,  153.,  154.,  153.,  154.,
      155.,  156.,  155.,  156.,  157.,  158.,  157.,  158.,  159.,  160.,
      161.,  162.,  163.,  164.,  165.,  166.,  167.,  168.,  167.,  168.,
      169.,  170.,  169.,  170.,  171.,  172.,  171.,  172.,  173.,  174.,
      187.,  188.,  189.,  190.,  189.,  190.,  191.,  192.,  191.,  192.,
      193.,  194.,  193.,  194.,  195.,  196.,  197.,  198.,  199.,  200.,
      201.,  202.,  203.,  204.,  203.,  204.,  205.,  206.,  205.,  206.,
      207.,  208.,  207.,  208.,  209.,  210.,  223.,  224.,  225.,  226.,
      225.,  226.,  227.,  228.,  227.,  228.,  229.,  230.,  229.,  230.,
      231.,  232.,  233.,  234.,  235.,  236.,  237.,  238.,  239.,  240.,
      239.,  240.,  241.,  242.,  241.,  242.,  243.,  244.,  243.,  244.,
      245.,  246.,  241.,  242.,  243.,  244.,  243.,  244.,  245.,  246.,
      245.,  246.,  247.,  248.,  247.,  248.,  249.,  250.,  251.,  252.,
      253.,  254.,  255.,  256.,  257.,  258.,  257.,  258.,  259.,  260.,
      259.,  260.,  261.,  262.,  261.,  262.,  263.,  264.,  259.,  260.,
      261.,  262.,  261.,  262.,  263.,  264.,  263.,  264.,  265.,  266.,
      265.,  266.,  267.,  268.,  269.,  270.,  271.,  272.,  273.,  274.,
      275.,  276.,  275.,  276.,  277.,  278.,  277.,  278.,  279.,  280.,
      279.,  280.,  281.,  282.,  277.,  278.,  279.,  280.,  279.,  280.,
      281.,  282.,  281.,  282.,  283.,  284.,  283.,  284.,  285.,  286.,
      287.,  288.,  289.,  290.,  291.,  292.,  293.,  294.,  293.,  294.,
      295.,  296.,  295.,  296.,  297.,  298.,  297.,  298.,  299.,  300.,
      421.,  422.,  423.,  424.,  423.,  424.,  425.,  426.,  425.,  426.,
      427.,  428.,  427.,  428.,  429.,  430.,  431.,  432.,  433.,  434.,
      435.,  436.,  437.,  438.,  437.,  438.,  439.,  440.,  439.,  440.,
      441.,  442.,  441.,  442.,  443.,  444.,  439.,  440.,  441.,  442.,
      441.,  442.,  443.,  444.,  443.,  444.,  445.,  446.,  445.,  446.,
      447.,  448.,  449.,  450.,  451.,  452.,  453.,  454.,  455.,  456.,
      455.,  456.,  457.,  458.,  457.,  458.,  459.,  460.,  459.,  460.,
      461.,  462.,  457.,  458.,  459.,  460.,  459.,  460.,  461.,  462.,
      461.,  462.,  463.,  464.,  463.,  464.,  465.,  466.,  467.,  468.,
      469.,  470.,  471.,  472.,  473.,  474.,  473.,  474.,  475.,  476.,
      475.,  476.,  477.,  478.,  477.,  478.,  479.,  480.,  475.,  476.,
      477.,  478.,  477.,  478.,  479.,  480.,  479.,  480.,  481.,  482.,
      481.,  482.,  483.,  484.,  485.,  486.,  487.,  488.,  489.,  490.,
      491.,  492.,  491.,  492.,  493.,  494.,  493.,  494.,  495.,  496.,
      495.,  496.,  497.,  498.,  511.,  512.,  513.,  514.,  513.,  514.,
      515.,  516.,  515.,  516.,  517.,  518.,  517.,  518.,  519.,  520.,
      521.,  522.,  523.,  524.,  525.,  526.,  527.,  528.,  527.,  528.,
      529.,  530.,  529.,  530.,  531.,  532.,  531.,  532.,  533.,  534.,
      547.,  548.,  549.,  550.,  549.,  550.,  551.,  552.,  551.,  552.,
      553.,  554.,  553.,  554.,  555.,  556.,  557.,  558.,  559.,  560.,
      561.,  562.,  563.,  564.,  563.,  564.,  565.,  566.,  565.,  566.,
      567.,  568.,  567.,  568.,  569.,  570.,  583.,  584.,  585.,  586.,
      585.,  586.,  587.,  588.,  587.,  588.,  589.,  590.,  589.,  590.,
      591.,  592.,  593.,  594.,  595.,  596.,  597.,  598.,  599.,  600.,
      599.,  600.,  601.,  602.,  601.,  602.,  603.,  604.,  603.,  604.,
      605.,  606.,  601.,  602.,  603.,  604.,  603.,  604.,  605.,  606.,
      605.,  606.,  607.,  608.,  607.,  608.,  609.,  610.,  611.,  612.,
      613.,  614.,  615.,  616.,  617.,  618.,  617.,  618.,  619.,  620.,
      619.,  620.,  621.,  622.,  621.,  622.,  623.,  624.,  619.,  620.,
      621.,  622.,  621.,  622.,  623.,  624.,  623.,  624.,  625.,  626.,
      625.,  626.,  627.,  628.,  629.,  630.,  631.,  632.,  633.,  634.,
      635.,  636.,  635.,  636.,  637.,  638.,  637.,  638.,  639.,  640.,
      639.,  640.,  641.,  642.,  637.,  638.,  639.,  640.,  639.,  640.,
      641.,  642.,  641.,  642.,  643.,  644.,  643.,  644.,  645.,  646.,
      647.,  648.,  649.,  650.,  651.,  652.,  653.,  654.,  653.,  654.,
      655.,  656.,  655.,  656.,  657.,  658.,  657.,  658.,  659.,  660.,
      781.,  782.,  783.,  784.,  783.,  784.,  785.,  786.,  785.,  786.,
      787.,  788.,  787.,  788.,  789.,  790.,  791.,  792.,  793.,  794.,
      795.,  796.,  797.,  798.,  797.,  798.,  799.,  800.,  799.,  800.,
      801.,  802.,  801.,  802.,  803.,  804.,  799.,  800.,  801.,  802.,
      801.,  802.,  803.,  804.,  803.,  804.,  805.,  806.,  805.,  806.,
      807.,  808.,  809.,  810.,  811.,  812.,  813.,  814.,  815.,  816.,
      815.,  816.,  817.,  818.,  817.,  818.,  819.,  820.,  819.,  820.,
      821.,  822.,  817.,  818.,  819.,  820.,  819.,  820.,  821.,  822.,
      821.,  822.,  823.,  824.,  823.,  824.,  825.,  826.,  827.,  828.,
      829.,  830.,  831.,  832.,  833.,  834.,  833.,  834.,  835.,  836.,
      835.,  836.,  837.,  838.,  837.,  838.,  839.,  840.,  835.,  836.,
      837.,  838.,  837.,  838.,  839.,  840.,  839.,  840.,  841.,  842.,
      841.,  842.,  843.,  844.,  845.,  846.,  847.,  848.,  849.,  850.,
      851.,  852.,  851.,  852.,  853.,  854.,  853.,  854.,  855.,  856.,
      855.,  856.,  857.,  858.,  871.,  872.,  873.,  874.,  873.,  874.,
      875.,  876.,  875.,  876.,  877.,  878.,  877.,  878.,  879.,  880.,
      881.,  882.,  883.,  884.,  885.,  886.,  887.,  888.,  887.,  888.,
      889.,  890.,  889.,  890.,  891.,  892.,  891.,  892.,  893.,  894.,
      907.,  908.,  909.,  910.,  909.,  910.,  911.,  912.,  911.,  912.,
      913.,  914.,  913.,  914.,  915.,  916.,  917.,  918.,  919.,  920.,
      921.,  922.,  923.,  924.,  923.,  924.,  925.,  926.,  925.,  926.,
      927.,  928.,  927.,  928.,  929.,  930.,  943.,  944.,  945.,  946.,
      945.,  946.,  947.,  948.,  947.,  948.,  949.,  950.,  949.,  950.,
      951.,  952.,  953.,  954.,  955.,  956.,  957.,  958.,  959.,  960.,
      959.,  960.,  961.,  962.,  961.,  962.,  963.,  964.,  963.,  964.,
      965.,  966.,  961.,  962.,  963.,  964.,  963.,  964.,  965.,  966.,
      965.,  966.,  967.,  968.,  967.,  968.,  969.,  970.,  971.,  972.,
      973.,  974.,  975.,  976.,  977.,  978.,  977.,  978.,  979.,  980.,
      979.,  980.,  981.,  982.,  981.,  982.,  983.,  984.,  979.,  980.,
      981.,  982.,  981.,  982.,  983.,  984.,  983.,  984.,  985.,  986.,
      985.,  986.,  987.,  988.,  989.,  990.,  991.,  992.,  993.,  994.,
      995.,  996.,  995.,  996.,  997.,  998.,  997.,  998.,  999.,  1000.,
      999.,  1000., 1001., 1002., 997.,  998.,  999.,  1000., 999.,  1000.,
      1001., 1002., 1001., 1002., 1003., 1004., 1003., 1004., 1005., 1006.,
      1007., 1008., 1009., 1010., 1011., 1012., 1013., 1014., 1013., 1014.,
      1015., 1016., 1015., 1016., 1017., 1018., 1017., 1018., 1019., 1020.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      481., 482., 483., 484., 485., 486., 487., 488., 489., 490., 491., 492.,
      517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527., 528.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.,
      877., 878., 879., 880., 881., 882., 883., 884., 885., 886., 887., 888.,
      913., 914., 915., 916., 917., 918., 919., 920., 921., 922., 923., 924.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.5,  18.,  18.5,  19.,  20.,  21.,  22.,  22.5,  23.,  23.5,
      22.5,  23.,  23.5,  24.,  25.,  26.,  27.,  27.5,  28.,  28.5,
      27.5,  28.,  28.5,  29.,  30.,  31.,  32.,  32.5,  33.,  33.5,
      32.5,  33.,  33.5,  34.,  35.,  36.,  37.,  37.5,  38.,  38.5,
      42.5,  43.,  43.5,  44.,  45.,  46.,  47.,  47.5,  48.,  48.5,
      52.5,  53.,  53.5,  54.,  55.,  56.,  57.,  57.5,  58.,  58.5,
      62.5,  63.,  63.5,  64.,  65.,  66.,  67.,  67.5,  68.,  68.5,
      67.5,  68.,  68.5,  69.,  70.,  71.,  72.,  72.5,  73.,  73.5,
      72.5,  73.,  73.5,  74.,  75.,  76.,  77.,  77.5,  78.,  78.5,
      77.5,  78.,  78.5,  79.,  80.,  81.,  82.,  82.5,  83.,  83.5,
      117.5, 118., 118.5, 119., 120., 121., 122., 122.5, 123., 123.5,
      122.5, 123., 123.5, 124., 125., 126., 127., 127.5, 128., 128.5,
      127.5, 128., 128.5, 129., 130., 131., 132., 132.5, 133., 133.5,
      132.5, 133., 133.5, 134., 135., 136., 137., 137.5, 138., 138.5,
      142.5, 143., 143.5, 144., 145., 146., 147., 147.5, 148., 148.5,
      152.5, 153., 153.5, 154., 155., 156., 157., 157.5, 158., 158.5,
      162.5, 163., 163.5, 164., 165., 166., 167., 167.5, 168., 168.5,
      167.5, 168., 168.5, 169., 170., 171., 172., 172.5, 173., 173.5,
      172.5, 173., 173.5, 174., 175., 176., 177., 177.5, 178., 178.5,
      177.5, 178., 178.5, 179., 180., 181., 182., 182.5, 183., 183.5,
      217.5, 218., 218.5, 219., 220., 221., 222., 222.5, 223., 223.5,
      222.5, 223., 223.5, 224., 225., 226., 227., 227.5, 228., 228.5,
      227.5, 228., 228.5, 229., 230., 231., 232., 232.5, 233., 233.5,
      232.5, 233., 233.5, 234., 235., 236., 237., 237.5, 238., 238.5,
      242.5, 243., 243.5, 244., 245., 246., 247., 247.5, 248., 248.5,
      252.5, 253., 253.5, 254., 255., 256., 257., 257.5, 258., 258.5,
      262.5, 263., 263.5, 264., 265., 266., 267., 267.5, 268., 268.5,
      267.5, 268., 268.5, 269., 270., 271., 272., 272.5, 273., 273.5,
      272.5, 273., 273.5, 274., 275., 276., 277., 277.5, 278., 278.5,
      277.5, 278., 278.5, 279., 280., 281., 282., 282.5, 283., 283.5};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  36.,  37.,  44.,  45.,  46.,  47.,  54.,  55.,  56.,  57.,
      64.,  65.,  66.,  67.,  134., 135., 136., 137., 144., 145., 146., 147.,
      154., 155., 156., 157., 164., 165., 166., 167., 234., 235., 236., 237.,
      244., 245., 246., 247., 254., 255., 256., 257., 264., 265., 266., 267.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  35.,  36.,  36.,  37.,  37.,  38.,  39.,  40.,  41.,  42.,
      43.,  44.,  44.,  45.,  45.,  46.,  46.,  47.,  44.,  45.,  45.,  46.,
      46.,  47.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  54.,  55.,
      55.,  56.,  56.,  57.,  54.,  55.,  55.,  56.,  56.,  57.,  57.,  58.,
      59.,  60.,  61.,  62.,  63.,  64.,  64.,  65.,  65.,  66.,  66.,  67.,
      64.,  65.,  65.,  66.,  66.,  67.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  74.,  75.,  75.,  76.,  76.,  77.,  84.,  85.,  85.,  86.,
      86.,  87.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  94.,  95.,
      95.,  96.,  96.,  97.,  104., 105., 105., 106., 106., 107., 107., 108.,
      109., 110., 111., 112., 113., 114., 114., 115., 115., 116., 116., 117.,
      124., 125., 125., 126., 126., 127., 127., 128., 129., 130., 131., 132.,
      133., 134., 134., 135., 135., 136., 136., 137., 134., 135., 135., 136.,
      136., 137., 137., 138., 139., 140., 141., 142., 143., 144., 144., 145.,
      145., 146., 146., 147., 144., 145., 145., 146., 146., 147., 147., 148.,
      149., 150., 151., 152., 153., 154., 154., 155., 155., 156., 156., 157.,
      154., 155., 155., 156., 156., 157., 157., 158., 159., 160., 161., 162.,
      163., 164., 164., 165., 165., 166., 166., 167., 234., 235., 235., 236.,
      236., 237., 237., 238., 239., 240., 241., 242., 243., 244., 244., 245.,
      245., 246., 246., 247., 244., 245., 245., 246., 246., 247., 247., 248.,
      249., 250., 251., 252., 253., 254., 254., 255., 255., 256., 256., 257.,
      254., 255., 255., 256., 256., 257., 257., 258., 259., 260., 261., 262.,
      263., 264., 264., 265., 265., 266., 266., 267., 264., 265., 265., 266.,
      266., 267., 267., 268., 269., 270., 271., 272., 273., 274., 274., 275.,
      275., 276., 276., 277., 284., 285., 285., 286., 286., 287., 287., 288.,
      289., 290., 291., 292., 293., 294., 294., 295., 295., 296., 296., 297.,
      304., 305., 305., 306., 306., 307., 307., 308., 309., 310., 311., 312.,
      313., 314., 314., 315., 315., 316., 316., 317., 324., 325., 325., 326.,
      326., 327., 327., 328., 329., 330., 331., 332., 333., 334., 334., 335.,
      335., 336., 336., 337., 334., 335., 335., 336., 336., 337., 337., 338.,
      339., 340., 341., 342., 343., 344., 344., 345., 345., 346., 346., 347.,
      344., 345., 345., 346., 346., 347., 347., 348., 349., 350., 351., 352.,
      353., 354., 354., 355., 355., 356., 356., 357., 354., 355., 355., 356.,
      356., 357., 357., 358., 359., 360., 361., 362., 363., 364., 364., 365.,
      365., 366., 366., 367., 434., 435., 435., 436., 436., 437., 437., 438.,
      439., 440., 441., 442., 443., 444., 444., 445., 445., 446., 446., 447.,
      444., 445., 445., 446., 446., 447., 447., 448., 449., 450., 451., 452.,
      453., 454., 454., 455., 455., 456., 456., 457., 454., 455., 455., 456.,
      456., 457., 457., 458., 459., 460., 461., 462., 463., 464., 464., 465.,
      465., 466., 466., 467., 464., 465., 465., 466., 466., 467., 467., 468.,
      469., 470., 471., 472., 473., 474., 474., 475., 475., 476., 476., 477.,
      484., 485., 485., 486., 486., 487., 487., 488., 489., 490., 491., 492.,
      493., 494., 494., 495., 495., 496., 496., 497., 504., 505., 505., 506.,
      506., 507., 507., 508., 509., 510., 511., 512., 513., 514., 514., 515.,
      515., 516., 516., 517., 524., 525., 525., 526., 526., 527., 527., 528.,
      529., 530., 531., 532., 533., 534., 534., 535., 535., 536., 536., 537.,
      534., 535., 535., 536., 536., 537., 537., 538., 539., 540., 541., 542.,
      543., 544., 544., 545., 545., 546., 546., 547., 544., 545., 545., 546.,
      546., 547., 547., 548., 549., 550., 551., 552., 553., 554., 554., 555.,
      555., 556., 556., 557., 554., 555., 555., 556., 556., 557., 557., 558.,
      559., 560., 561., 562., 563., 564., 564., 565., 565., 566., 566., 567.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  107., 108., 109., 110., 111., 112., 113., 114.,
      127., 128., 129., 130., 131., 132., 133., 134., 267., 268., 269., 270.,
      271., 272., 273., 274., 287., 288., 289., 290., 291., 292., 293., 294.,
      307., 308., 309., 310., 311., 312., 313., 314., 327., 328., 329., 330.,
      331., 332., 333., 334., 467., 468., 469., 470., 471., 472., 473., 474.,
      487., 488., 489., 490., 491., 492., 493., 494., 507., 508., 509., 510.,
      511., 512., 513., 514., 527., 528., 529., 530., 531., 532., 533., 534.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, SAME3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,   68.,   69.,   70.,   69.,   70.,   71.,   72.,   71.,   72.,
      73.,   74.,   73.,   74.,   75.,   76.,   77.,   78.,   79.,   80.,
      81.,   82.,   83.,   84.,   85.,   86.,   87.,   88.,   87.,   88.,
      89.,   90.,   89.,   90.,   91.,   92.,   91.,   92.,   93.,   94.,
      87.,   88.,   89.,   90.,   89.,   90.,   91.,   92.,   91.,   92.,
      93.,   94.,   93.,   94.,   95.,   96.,   97.,   98.,   99.,   100.,
      101.,  102.,  103.,  104.,  105.,  106.,  107.,  108.,  107.,  108.,
      109.,  110.,  109.,  110.,  111.,  112.,  111.,  112.,  113.,  114.,
      107.,  108.,  109.,  110.,  109.,  110.,  111.,  112.,  111.,  112.,
      113.,  114.,  113.,  114.,  115.,  116.,  117.,  118.,  119.,  120.,
      121.,  122.,  123.,  124.,  125.,  126.,  127.,  128.,  127.,  128.,
      129.,  130.,  129.,  130.,  131.,  132.,  131.,  132.,  133.,  134.,
      127.,  128.,  129.,  130.,  129.,  130.,  131.,  132.,  131.,  132.,
      133.,  134.,  133.,  134.,  135.,  136.,  137.,  138.,  139.,  140.,
      141.,  142.,  143.,  144.,  145.,  146.,  147.,  148.,  147.,  148.,
      149.,  150.,  149.,  150.,  151.,  152.,  151.,  152.,  153.,  154.,
      167.,  168.,  169.,  170.,  169.,  170.,  171.,  172.,  171.,  172.,
      173.,  174.,  173.,  174.,  175.,  176.,  177.,  178.,  179.,  180.,
      181.,  182.,  183.,  184.,  185.,  186.,  187.,  188.,  187.,  188.,
      189.,  190.,  189.,  190.,  191.,  192.,  191.,  192.,  193.,  194.,
      207.,  208.,  209.,  210.,  209.,  210.,  211.,  212.,  211.,  212.,
      213.,  214.,  213.,  214.,  215.,  216.,  217.,  218.,  219.,  220.,
      221.,  222.,  223.,  224.,  225.,  226.,  227.,  228.,  227.,  228.,
      229.,  230.,  229.,  230.,  231.,  232.,  231.,  232.,  233.,  234.,
      247.,  248.,  249.,  250.,  249.,  250.,  251.,  252.,  251.,  252.,
      253.,  254.,  253.,  254.,  255.,  256.,  257.,  258.,  259.,  260.,
      261.,  262.,  263.,  264.,  265.,  266.,  267.,  268.,  267.,  268.,
      269.,  270.,  269.,  270.,  271.,  272.,  271.,  272.,  273.,  274.,
      267.,  268.,  269.,  270.,  269.,  270.,  271.,  272.,  271.,  272.,
      273.,  274.,  273.,  274.,  275.,  276.,  277.,  278.,  279.,  280.,
      281.,  282.,  283.,  284.,  285.,  286.,  287.,  288.,  287.,  288.,
      289.,  290.,  289.,  290.,  291.,  292.,  291.,  292.,  293.,  294.,
      287.,  288.,  289.,  290.,  289.,  290.,  291.,  292.,  291.,  292.,
      293.,  294.,  293.,  294.,  295.,  296.,  297.,  298.,  299.,  300.,
      301.,  302.,  303.,  304.,  305.,  306.,  307.,  308.,  307.,  308.,
      309.,  310.,  309.,  310.,  311.,  312.,  311.,  312.,  313.,  314.,
      307.,  308.,  309.,  310.,  309.,  310.,  311.,  312.,  311.,  312.,
      313.,  314.,  313.,  314.,  315.,  316.,  317.,  318.,  319.,  320.,
      321.,  322.,  323.,  324.,  325.,  326.,  327.,  328.,  327.,  328.,
      329.,  330.,  329.,  330.,  331.,  332.,  331.,  332.,  333.,  334.,
      467.,  468.,  469.,  470.,  469.,  470.,  471.,  472.,  471.,  472.,
      473.,  474.,  473.,  474.,  475.,  476.,  477.,  478.,  479.,  480.,
      481.,  482.,  483.,  484.,  485.,  486.,  487.,  488.,  487.,  488.,
      489.,  490.,  489.,  490.,  491.,  492.,  491.,  492.,  493.,  494.,
      487.,  488.,  489.,  490.,  489.,  490.,  491.,  492.,  491.,  492.,
      493.,  494.,  493.,  494.,  495.,  496.,  497.,  498.,  499.,  500.,
      501.,  502.,  503.,  504.,  505.,  506.,  507.,  508.,  507.,  508.,
      509.,  510.,  509.,  510.,  511.,  512.,  511.,  512.,  513.,  514.,
      507.,  508.,  509.,  510.,  509.,  510.,  511.,  512.,  511.,  512.,
      513.,  514.,  513.,  514.,  515.,  516.,  517.,  518.,  519.,  520.,
      521.,  522.,  523.,  524.,  525.,  526.,  527.,  528.,  527.,  528.,
      529.,  530.,  529.,  530.,  531.,  532.,  531.,  532.,  533.,  534.,
      527.,  528.,  529.,  530.,  529.,  530.,  531.,  532.,  531.,  532.,
      533.,  534.,  533.,  534.,  535.,  536.,  537.,  538.,  539.,  540.,
      541.,  542.,  543.,  544.,  545.,  546.,  547.,  548.,  547.,  548.,
      549.,  550.,  549.,  550.,  551.,  552.,  551.,  552.,  553.,  554.,
      567.,  568.,  569.,  570.,  569.,  570.,  571.,  572.,  571.,  572.,
      573.,  574.,  573.,  574.,  575.,  576.,  577.,  578.,  579.,  580.,
      581.,  582.,  583.,  584.,  585.,  586.,  587.,  588.,  587.,  588.,
      589.,  590.,  589.,  590.,  591.,  592.,  591.,  592.,  593.,  594.,
      607.,  608.,  609.,  610.,  609.,  610.,  611.,  612.,  611.,  612.,
      613.,  614.,  613.,  614.,  615.,  616.,  617.,  618.,  619.,  620.,
      621.,  622.,  623.,  624.,  625.,  626.,  627.,  628.,  627.,  628.,
      629.,  630.,  629.,  630.,  631.,  632.,  631.,  632.,  633.,  634.,
      647.,  648.,  649.,  650.,  649.,  650.,  651.,  652.,  651.,  652.,
      653.,  654.,  653.,  654.,  655.,  656.,  657.,  658.,  659.,  660.,
      661.,  662.,  663.,  664.,  665.,  666.,  667.,  668.,  667.,  668.,
      669.,  670.,  669.,  670.,  671.,  672.,  671.,  672.,  673.,  674.,
      667.,  668.,  669.,  670.,  669.,  670.,  671.,  672.,  671.,  672.,
      673.,  674.,  673.,  674.,  675.,  676.,  677.,  678.,  679.,  680.,
      681.,  682.,  683.,  684.,  685.,  686.,  687.,  688.,  687.,  688.,
      689.,  690.,  689.,  690.,  691.,  692.,  691.,  692.,  693.,  694.,
      687.,  688.,  689.,  690.,  689.,  690.,  691.,  692.,  691.,  692.,
      693.,  694.,  693.,  694.,  695.,  696.,  697.,  698.,  699.,  700.,
      701.,  702.,  703.,  704.,  705.,  706.,  707.,  708.,  707.,  708.,
      709.,  710.,  709.,  710.,  711.,  712.,  711.,  712.,  713.,  714.,
      707.,  708.,  709.,  710.,  709.,  710.,  711.,  712.,  711.,  712.,
      713.,  714.,  713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,
      721.,  722.,  723.,  724.,  725.,  726.,  727.,  728.,  727.,  728.,
      729.,  730.,  729.,  730.,  731.,  732.,  731.,  732.,  733.,  734.,
      867.,  868.,  869.,  870.,  869.,  870.,  871.,  872.,  871.,  872.,
      873.,  874.,  873.,  874.,  875.,  876.,  877.,  878.,  879.,  880.,
      881.,  882.,  883.,  884.,  885.,  886.,  887.,  888.,  887.,  888.,
      889.,  890.,  889.,  890.,  891.,  892.,  891.,  892.,  893.,  894.,
      887.,  888.,  889.,  890.,  889.,  890.,  891.,  892.,  891.,  892.,
      893.,  894.,  893.,  894.,  895.,  896.,  897.,  898.,  899.,  900.,
      901.,  902.,  903.,  904.,  905.,  906.,  907.,  908.,  907.,  908.,
      909.,  910.,  909.,  910.,  911.,  912.,  911.,  912.,  913.,  914.,
      907.,  908.,  909.,  910.,  909.,  910.,  911.,  912.,  911.,  912.,
      913.,  914.,  913.,  914.,  915.,  916.,  917.,  918.,  919.,  920.,
      921.,  922.,  923.,  924.,  925.,  926.,  927.,  928.,  927.,  928.,
      929.,  930.,  929.,  930.,  931.,  932.,  931.,  932.,  933.,  934.,
      927.,  928.,  929.,  930.,  929.,  930.,  931.,  932.,  931.,  932.,
      933.,  934.,  933.,  934.,  935.,  936.,  937.,  938.,  939.,  940.,
      941.,  942.,  943.,  944.,  945.,  946.,  947.,  948.,  947.,  948.,
      949.,  950.,  949.,  950.,  951.,  952.,  951.,  952.,  953.,  954.,
      967.,  968.,  969.,  970.,  969.,  970.,  971.,  972.,  971.,  972.,
      973.,  974.,  973.,  974.,  975.,  976.,  977.,  978.,  979.,  980.,
      981.,  982.,  983.,  984.,  985.,  986.,  987.,  988.,  987.,  988.,
      989.,  990.,  989.,  990.,  991.,  992.,  991.,  992.,  993.,  994.,
      1007., 1008., 1009., 1010., 1009., 1010., 1011., 1012., 1011., 1012.,
      1013., 1014., 1013., 1014., 1015., 1016., 1017., 1018., 1019., 1020.,
      1021., 1022., 1023., 1024., 1025., 1026., 1027., 1028., 1027., 1028.,
      1029., 1030., 1029., 1030., 1031., 1032., 1031., 1032., 1033., 1034.,
      1047., 1048., 1049., 1050., 1049., 1050., 1051., 1052., 1051., 1052.,
      1053., 1054., 1053., 1054., 1055., 1056., 1057., 1058., 1059., 1060.,
      1061., 1062., 1063., 1064., 1065., 1066., 1067., 1068., 1067., 1068.,
      1069., 1070., 1069., 1070., 1071., 1072., 1071., 1072., 1073., 1074.,
      1067., 1068., 1069., 1070., 1069., 1070., 1071., 1072., 1071., 1072.,
      1073., 1074., 1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080.,
      1081., 1082., 1083., 1084., 1085., 1086., 1087., 1088., 1087., 1088.,
      1089., 1090., 1089., 1090., 1091., 1092., 1091., 1092., 1093., 1094.,
      1087., 1088., 1089., 1090., 1089., 1090., 1091., 1092., 1091., 1092.,
      1093., 1094., 1093., 1094., 1095., 1096., 1097., 1098., 1099., 1100.,
      1101., 1102., 1103., 1104., 1105., 1106., 1107., 1108., 1107., 1108.,
      1109., 1110., 1109., 1110., 1111., 1112., 1111., 1112., 1113., 1114.,
      1107., 1108., 1109., 1110., 1109., 1110., 1111., 1112., 1111., 1112.,
      1113., 1114., 1113., 1114., 1115., 1116., 1117., 1118., 1119., 1120.,
      1121., 1122., 1123., 1124., 1125., 1126., 1127., 1128., 1127., 1128.,
      1129., 1130., 1129., 1130., 1131., 1132., 1131., 1132., 1133., 1134.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride1Forward, VALID3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133.,  134.,  135.,  136.,  137.,  138.,  139.,  140.,  141.,  142.,
      143.,  144.,  145.,  146.,  147.,  148.,  173.,  174.,  175.,  176.,
      177.,  178.,  179.,  180.,  181.,  182.,  183.,  184.,  185.,  186.,
      187.,  188.,  213.,  214.,  215.,  216.,  217.,  218.,  219.,  220.,
      221.,  222.,  223.,  224.,  225.,  226.,  227.,  228.,  253.,  254.,
      255.,  256.,  257.,  258.,  259.,  260.,  261.,  262.,  263.,  264.,
      265.,  266.,  267.,  268.,  533.,  534.,  535.,  536.,  537.,  538.,
      539.,  540.,  541.,  542.,  543.,  544.,  545.,  546.,  547.,  548.,
      573.,  574.,  575.,  576.,  577.,  578.,  579.,  580.,  581.,  582.,
      583.,  584.,  585.,  586.,  587.,  588.,  613.,  614.,  615.,  616.,
      617.,  618.,  619.,  620.,  621.,  622.,  623.,  624.,  625.,  626.,
      627.,  628.,  653.,  654.,  655.,  656.,  657.,  658.,  659.,  660.,
      661.,  662.,  663.,  664.,  665.,  666.,  667.,  668.,  933.,  934.,
      935.,  936.,  937.,  938.,  939.,  940.,  941.,  942.,  943.,  944.,
      945.,  946.,  947.,  948.,  973.,  974.,  975.,  976.,  977.,  978.,
      979.,  980.,  981.,  982.,  983.,  984.,  985.,  986.,  987.,  988.,
      1013., 1014., 1015., 1016., 1017., 1018., 1019., 1020., 1021., 1022.,
      1023., 1024., 1025., 1026., 1027., 1028., 1053., 1054., 1055., 1056.,
      1057., 1058., 1059., 1060., 1061., 1062., 1063., 1064., 1065., 1066.,
      1067., 1068.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
